| 1: | <?php |
| 2: | // @formatter:off |
| 3: | // phpcs:ignoreFile |
| 4: | |
| 5: | /** |
| 6: | * A helper file for Laravel, to provide autocomplete information to your IDE |
| 7: | * Generated for Laravel 9.21.3. |
| 8: | * |
| 9: | * This file should not be included in your code, only analyzed by your IDE! |
| 10: | * |
| 11: | * @author Barry vd. Heuvel <barryvdh@gmail.com> |
| 12: | * @see https://github.com/barryvdh/laravel-ide-helper |
| 13: | */ |
| 14: | |
| 15: | namespace Illuminate\Support\Facades { |
| 16: | /** |
| 17: | * |
| 18: | * |
| 19: | * @see \Illuminate\Contracts\Foundation\Application |
| 20: | */ |
| 21: | class App { |
| 22: | /** |
| 23: | * Get the version number of the application. |
| 24: | * |
| 25: | * @return string |
| 26: | * @static |
| 27: | */ |
| 28: | public static function version() |
| 29: | { |
| 30: | /** @var \Illuminate\Foundation\Application $instance */ |
| 31: | return $instance->version(); |
| 32: | } |
| 33: | /** |
| 34: | * Run the given array of bootstrap classes. |
| 35: | * |
| 36: | * @param string[] $bootstrappers |
| 37: | * @return void |
| 38: | * @static |
| 39: | */ |
| 40: | public static function bootstrapWith($bootstrappers) |
| 41: | { |
| 42: | /** @var \Illuminate\Foundation\Application $instance */ |
| 43: | $instance->bootstrapWith($bootstrappers); |
| 44: | } |
| 45: | /** |
| 46: | * Register a callback to run after loading the environment. |
| 47: | * |
| 48: | * @param \Closure $callback |
| 49: | * @return void |
| 50: | * @static |
| 51: | */ |
| 52: | public static function afterLoadingEnvironment($callback) |
| 53: | { |
| 54: | /** @var \Illuminate\Foundation\Application $instance */ |
| 55: | $instance->afterLoadingEnvironment($callback); |
| 56: | } |
| 57: | /** |
| 58: | * Register a callback to run before a bootstrapper. |
| 59: | * |
| 60: | * @param string $bootstrapper |
| 61: | * @param \Closure $callback |
| 62: | * @return void |
| 63: | * @static |
| 64: | */ |
| 65: | public static function beforeBootstrapping($bootstrapper, $callback) |
| 66: | { |
| 67: | /** @var \Illuminate\Foundation\Application $instance */ |
| 68: | $instance->beforeBootstrapping($bootstrapper, $callback); |
| 69: | } |
| 70: | /** |
| 71: | * Register a callback to run after a bootstrapper. |
| 72: | * |
| 73: | * @param string $bootstrapper |
| 74: | * @param \Closure $callback |
| 75: | * @return void |
| 76: | * @static |
| 77: | */ |
| 78: | public static function afterBootstrapping($bootstrapper, $callback) |
| 79: | { |
| 80: | /** @var \Illuminate\Foundation\Application $instance */ |
| 81: | $instance->afterBootstrapping($bootstrapper, $callback); |
| 82: | } |
| 83: | /** |
| 84: | * Determine if the application has been bootstrapped before. |
| 85: | * |
| 86: | * @return bool |
| 87: | * @static |
| 88: | */ |
| 89: | public static function hasBeenBootstrapped() |
| 90: | { |
| 91: | /** @var \Illuminate\Foundation\Application $instance */ |
| 92: | return $instance->hasBeenBootstrapped(); |
| 93: | } |
| 94: | /** |
| 95: | * Set the base path for the application. |
| 96: | * |
| 97: | * @param string $basePath |
| 98: | * @return \Illuminate\Foundation\Application |
| 99: | * @static |
| 100: | */ |
| 101: | public static function setBasePath($basePath) |
| 102: | { |
| 103: | /** @var \Illuminate\Foundation\Application $instance */ |
| 104: | return $instance->setBasePath($basePath); |
| 105: | } |
| 106: | /** |
| 107: | * Get the path to the application "app" directory. |
| 108: | * |
| 109: | * @param string $path |
| 110: | * @return string |
| 111: | * @static |
| 112: | */ |
| 113: | public static function path($path = '') |
| 114: | { |
| 115: | /** @var \Illuminate\Foundation\Application $instance */ |
| 116: | return $instance->path($path); |
| 117: | } |
| 118: | /** |
| 119: | * Set the application directory. |
| 120: | * |
| 121: | * @param string $path |
| 122: | * @return \Illuminate\Foundation\Application |
| 123: | * @static |
| 124: | */ |
| 125: | public static function useAppPath($path) |
| 126: | { |
| 127: | /** @var \Illuminate\Foundation\Application $instance */ |
| 128: | return $instance->useAppPath($path); |
| 129: | } |
| 130: | /** |
| 131: | * Get the base path of the Laravel installation. |
| 132: | * |
| 133: | * @param string $path |
| 134: | * @return string |
| 135: | * @static |
| 136: | */ |
| 137: | public static function basePath($path = '') |
| 138: | { |
| 139: | /** @var \Illuminate\Foundation\Application $instance */ |
| 140: | return $instance->basePath($path); |
| 141: | } |
| 142: | /** |
| 143: | * Get the path to the bootstrap directory. |
| 144: | * |
| 145: | * @param string $path |
| 146: | * @return string |
| 147: | * @static |
| 148: | */ |
| 149: | public static function bootstrapPath($path = '') |
| 150: | { |
| 151: | /** @var \Illuminate\Foundation\Application $instance */ |
| 152: | return $instance->bootstrapPath($path); |
| 153: | } |
| 154: | /** |
| 155: | * Get the path to the application configuration files. |
| 156: | * |
| 157: | * @param string $path |
| 158: | * @return string |
| 159: | * @static |
| 160: | */ |
| 161: | public static function configPath($path = '') |
| 162: | { |
| 163: | /** @var \Illuminate\Foundation\Application $instance */ |
| 164: | return $instance->configPath($path); |
| 165: | } |
| 166: | /** |
| 167: | * Get the path to the database directory. |
| 168: | * |
| 169: | * @param string $path |
| 170: | * @return string |
| 171: | * @static |
| 172: | */ |
| 173: | public static function databasePath($path = '') |
| 174: | { |
| 175: | /** @var \Illuminate\Foundation\Application $instance */ |
| 176: | return $instance->databasePath($path); |
| 177: | } |
| 178: | /** |
| 179: | * Set the database directory. |
| 180: | * |
| 181: | * @param string $path |
| 182: | * @return \Illuminate\Foundation\Application |
| 183: | * @static |
| 184: | */ |
| 185: | public static function useDatabasePath($path) |
| 186: | { |
| 187: | /** @var \Illuminate\Foundation\Application $instance */ |
| 188: | return $instance->useDatabasePath($path); |
| 189: | } |
| 190: | /** |
| 191: | * Get the path to the language files. |
| 192: | * |
| 193: | * @param string $path |
| 194: | * @return string |
| 195: | * @static |
| 196: | */ |
| 197: | public static function langPath($path = '') |
| 198: | { |
| 199: | /** @var \Illuminate\Foundation\Application $instance */ |
| 200: | return $instance->langPath($path); |
| 201: | } |
| 202: | /** |
| 203: | * Set the language file directory. |
| 204: | * |
| 205: | * @param string $path |
| 206: | * @return \Illuminate\Foundation\Application |
| 207: | * @static |
| 208: | */ |
| 209: | public static function useLangPath($path) |
| 210: | { |
| 211: | /** @var \Illuminate\Foundation\Application $instance */ |
| 212: | return $instance->useLangPath($path); |
| 213: | } |
| 214: | /** |
| 215: | * Get the path to the public / web directory. |
| 216: | * |
| 217: | * @return string |
| 218: | * @static |
| 219: | */ |
| 220: | public static function publicPath() |
| 221: | { |
| 222: | /** @var \Illuminate\Foundation\Application $instance */ |
| 223: | return $instance->publicPath(); |
| 224: | } |
| 225: | /** |
| 226: | * Get the path to the storage directory. |
| 227: | * |
| 228: | * @param string $path |
| 229: | * @return string |
| 230: | * @static |
| 231: | */ |
| 232: | public static function storagePath($path = '') |
| 233: | { |
| 234: | /** @var \Illuminate\Foundation\Application $instance */ |
| 235: | return $instance->storagePath($path); |
| 236: | } |
| 237: | /** |
| 238: | * Set the storage directory. |
| 239: | * |
| 240: | * @param string $path |
| 241: | * @return \Illuminate\Foundation\Application |
| 242: | * @static |
| 243: | */ |
| 244: | public static function useStoragePath($path) |
| 245: | { |
| 246: | /** @var \Illuminate\Foundation\Application $instance */ |
| 247: | return $instance->useStoragePath($path); |
| 248: | } |
| 249: | /** |
| 250: | * Get the path to the resources directory. |
| 251: | * |
| 252: | * @param string $path |
| 253: | * @return string |
| 254: | * @static |
| 255: | */ |
| 256: | public static function resourcePath($path = '') |
| 257: | { |
| 258: | /** @var \Illuminate\Foundation\Application $instance */ |
| 259: | return $instance->resourcePath($path); |
| 260: | } |
| 261: | /** |
| 262: | * Get the path to the views directory. |
| 263: | * |
| 264: | * This method returns the first configured path in the array of view paths. |
| 265: | * |
| 266: | * @param string $path |
| 267: | * @return string |
| 268: | * @static |
| 269: | */ |
| 270: | public static function viewPath($path = '') |
| 271: | { |
| 272: | /** @var \Illuminate\Foundation\Application $instance */ |
| 273: | return $instance->viewPath($path); |
| 274: | } |
| 275: | /** |
| 276: | * Get the path to the environment file directory. |
| 277: | * |
| 278: | * @return string |
| 279: | * @static |
| 280: | */ |
| 281: | public static function environmentPath() |
| 282: | { |
| 283: | /** @var \Illuminate\Foundation\Application $instance */ |
| 284: | return $instance->environmentPath(); |
| 285: | } |
| 286: | /** |
| 287: | * Set the directory for the environment file. |
| 288: | * |
| 289: | * @param string $path |
| 290: | * @return \Illuminate\Foundation\Application |
| 291: | * @static |
| 292: | */ |
| 293: | public static function useEnvironmentPath($path) |
| 294: | { |
| 295: | /** @var \Illuminate\Foundation\Application $instance */ |
| 296: | return $instance->useEnvironmentPath($path); |
| 297: | } |
| 298: | /** |
| 299: | * Set the environment file to be loaded during bootstrapping. |
| 300: | * |
| 301: | * @param string $file |
| 302: | * @return \Illuminate\Foundation\Application |
| 303: | * @static |
| 304: | */ |
| 305: | public static function loadEnvironmentFrom($file) |
| 306: | { |
| 307: | /** @var \Illuminate\Foundation\Application $instance */ |
| 308: | return $instance->loadEnvironmentFrom($file); |
| 309: | } |
| 310: | /** |
| 311: | * Get the environment file the application is using. |
| 312: | * |
| 313: | * @return string |
| 314: | * @static |
| 315: | */ |
| 316: | public static function environmentFile() |
| 317: | { |
| 318: | /** @var \Illuminate\Foundation\Application $instance */ |
| 319: | return $instance->environmentFile(); |
| 320: | } |
| 321: | /** |
| 322: | * Get the fully qualified path to the environment file. |
| 323: | * |
| 324: | * @return string |
| 325: | * @static |
| 326: | */ |
| 327: | public static function environmentFilePath() |
| 328: | { |
| 329: | /** @var \Illuminate\Foundation\Application $instance */ |
| 330: | return $instance->environmentFilePath(); |
| 331: | } |
| 332: | /** |
| 333: | * Get or check the current application environment. |
| 334: | * |
| 335: | * @param string|array $environments |
| 336: | * @return string|bool |
| 337: | * @static |
| 338: | */ |
| 339: | public static function environment(...$environments) |
| 340: | { |
| 341: | /** @var \Illuminate\Foundation\Application $instance */ |
| 342: | return $instance->environment(...$environments); |
| 343: | } |
| 344: | /** |
| 345: | * Determine if the application is in the local environment. |
| 346: | * |
| 347: | * @return bool |
| 348: | * @static |
| 349: | */ |
| 350: | public static function isLocal() |
| 351: | { |
| 352: | /** @var \Illuminate\Foundation\Application $instance */ |
| 353: | return $instance->isLocal(); |
| 354: | } |
| 355: | /** |
| 356: | * Determine if the application is in the production environment. |
| 357: | * |
| 358: | * @return bool |
| 359: | * @static |
| 360: | */ |
| 361: | public static function isProduction() |
| 362: | { |
| 363: | /** @var \Illuminate\Foundation\Application $instance */ |
| 364: | return $instance->isProduction(); |
| 365: | } |
| 366: | /** |
| 367: | * Detect the application's current environment. |
| 368: | * |
| 369: | * @param \Closure $callback |
| 370: | * @return string |
| 371: | * @static |
| 372: | */ |
| 373: | public static function detectEnvironment($callback) |
| 374: | { |
| 375: | /** @var \Illuminate\Foundation\Application $instance */ |
| 376: | return $instance->detectEnvironment($callback); |
| 377: | } |
| 378: | /** |
| 379: | * Determine if the application is running in the console. |
| 380: | * |
| 381: | * @return bool |
| 382: | * @static |
| 383: | */ |
| 384: | public static function runningInConsole() |
| 385: | { |
| 386: | /** @var \Illuminate\Foundation\Application $instance */ |
| 387: | return $instance->runningInConsole(); |
| 388: | } |
| 389: | /** |
| 390: | * Determine if the application is running unit tests. |
| 391: | * |
| 392: | * @return bool |
| 393: | * @static |
| 394: | */ |
| 395: | public static function runningUnitTests() |
| 396: | { |
| 397: | /** @var \Illuminate\Foundation\Application $instance */ |
| 398: | return $instance->runningUnitTests(); |
| 399: | } |
| 400: | /** |
| 401: | * Determine if the application is running with debug mode enabled. |
| 402: | * |
| 403: | * @return bool |
| 404: | * @static |
| 405: | */ |
| 406: | public static function hasDebugModeEnabled() |
| 407: | { |
| 408: | /** @var \Illuminate\Foundation\Application $instance */ |
| 409: | return $instance->hasDebugModeEnabled(); |
| 410: | } |
| 411: | /** |
| 412: | * Register all of the configured providers. |
| 413: | * |
| 414: | * @return void |
| 415: | * @static |
| 416: | */ |
| 417: | public static function registerConfiguredProviders() |
| 418: | { |
| 419: | /** @var \Illuminate\Foundation\Application $instance */ |
| 420: | $instance->registerConfiguredProviders(); |
| 421: | } |
| 422: | /** |
| 423: | * Register a service provider with the application. |
| 424: | * |
| 425: | * @param \Illuminate\Support\ServiceProvider|string $provider |
| 426: | * @param bool $force |
| 427: | * @return \Illuminate\Support\ServiceProvider |
| 428: | * @static |
| 429: | */ |
| 430: | public static function register($provider, $force = false) |
| 431: | { |
| 432: | /** @var \Illuminate\Foundation\Application $instance */ |
| 433: | return $instance->register($provider, $force); |
| 434: | } |
| 435: | /** |
| 436: | * Get the registered service provider instance if it exists. |
| 437: | * |
| 438: | * @param \Illuminate\Support\ServiceProvider|string $provider |
| 439: | * @return \Illuminate\Support\ServiceProvider|null |
| 440: | * @static |
| 441: | */ |
| 442: | public static function getProvider($provider) |
| 443: | { |
| 444: | /** @var \Illuminate\Foundation\Application $instance */ |
| 445: | return $instance->getProvider($provider); |
| 446: | } |
| 447: | /** |
| 448: | * Get the registered service provider instances if any exist. |
| 449: | * |
| 450: | * @param \Illuminate\Support\ServiceProvider|string $provider |
| 451: | * @return array |
| 452: | * @static |
| 453: | */ |
| 454: | public static function getProviders($provider) |
| 455: | { |
| 456: | /** @var \Illuminate\Foundation\Application $instance */ |
| 457: | return $instance->getProviders($provider); |
| 458: | } |
| 459: | /** |
| 460: | * Resolve a service provider instance from the class name. |
| 461: | * |
| 462: | * @param string $provider |
| 463: | * @return \Illuminate\Support\ServiceProvider |
| 464: | * @static |
| 465: | */ |
| 466: | public static function resolveProvider($provider) |
| 467: | { |
| 468: | /** @var \Illuminate\Foundation\Application $instance */ |
| 469: | return $instance->resolveProvider($provider); |
| 470: | } |
| 471: | /** |
| 472: | * Load and boot all of the remaining deferred providers. |
| 473: | * |
| 474: | * @return void |
| 475: | * @static |
| 476: | */ |
| 477: | public static function loadDeferredProviders() |
| 478: | { |
| 479: | /** @var \Illuminate\Foundation\Application $instance */ |
| 480: | $instance->loadDeferredProviders(); |
| 481: | } |
| 482: | /** |
| 483: | * Load the provider for a deferred service. |
| 484: | * |
| 485: | * @param string $service |
| 486: | * @return void |
| 487: | * @static |
| 488: | */ |
| 489: | public static function loadDeferredProvider($service) |
| 490: | { |
| 491: | /** @var \Illuminate\Foundation\Application $instance */ |
| 492: | $instance->loadDeferredProvider($service); |
| 493: | } |
| 494: | /** |
| 495: | * Register a deferred provider and service. |
| 496: | * |
| 497: | * @param string $provider |
| 498: | * @param string|null $service |
| 499: | * @return void |
| 500: | * @static |
| 501: | */ |
| 502: | public static function registerDeferredProvider($provider, $service = null) |
| 503: | { |
| 504: | /** @var \Illuminate\Foundation\Application $instance */ |
| 505: | $instance->registerDeferredProvider($provider, $service); |
| 506: | } |
| 507: | /** |
| 508: | * Resolve the given type from the container. |
| 509: | * |
| 510: | * @param string $abstract |
| 511: | * @param array $parameters |
| 512: | * @return mixed |
| 513: | * @static |
| 514: | */ |
| 515: | public static function make($abstract, $parameters = []) |
| 516: | { |
| 517: | /** @var \Illuminate\Foundation\Application $instance */ |
| 518: | return $instance->make($abstract, $parameters); |
| 519: | } |
| 520: | /** |
| 521: | * Determine if the given abstract type has been bound. |
| 522: | * |
| 523: | * @param string $abstract |
| 524: | * @return bool |
| 525: | * @static |
| 526: | */ |
| 527: | public static function bound($abstract) |
| 528: | { |
| 529: | /** @var \Illuminate\Foundation\Application $instance */ |
| 530: | return $instance->bound($abstract); |
| 531: | } |
| 532: | /** |
| 533: | * Determine if the application has booted. |
| 534: | * |
| 535: | * @return bool |
| 536: | * @static |
| 537: | */ |
| 538: | public static function isBooted() |
| 539: | { |
| 540: | /** @var \Illuminate\Foundation\Application $instance */ |
| 541: | return $instance->isBooted(); |
| 542: | } |
| 543: | /** |
| 544: | * Boot the application's service providers. |
| 545: | * |
| 546: | * @return void |
| 547: | * @static |
| 548: | */ |
| 549: | public static function boot() |
| 550: | { |
| 551: | /** @var \Illuminate\Foundation\Application $instance */ |
| 552: | $instance->boot(); |
| 553: | } |
| 554: | /** |
| 555: | * Register a new boot listener. |
| 556: | * |
| 557: | * @param callable $callback |
| 558: | * @return void |
| 559: | * @static |
| 560: | */ |
| 561: | public static function booting($callback) |
| 562: | { |
| 563: | /** @var \Illuminate\Foundation\Application $instance */ |
| 564: | $instance->booting($callback); |
| 565: | } |
| 566: | /** |
| 567: | * Register a new "booted" listener. |
| 568: | * |
| 569: | * @param callable $callback |
| 570: | * @return void |
| 571: | * @static |
| 572: | */ |
| 573: | public static function booted($callback) |
| 574: | { |
| 575: | /** @var \Illuminate\Foundation\Application $instance */ |
| 576: | $instance->booted($callback); |
| 577: | } |
| 578: | /** |
| 579: | * {@inheritdoc} |
| 580: | * |
| 581: | * @return \Symfony\Component\HttpFoundation\Response |
| 582: | * @static |
| 583: | */ |
| 584: | public static function handle($request, $type = 1, $catch = true) |
| 585: | { |
| 586: | /** @var \Illuminate\Foundation\Application $instance */ |
| 587: | return $instance->handle($request, $type, $catch); |
| 588: | } |
| 589: | /** |
| 590: | * Determine if middleware has been disabled for the application. |
| 591: | * |
| 592: | * @return bool |
| 593: | * @static |
| 594: | */ |
| 595: | public static function shouldSkipMiddleware() |
| 596: | { |
| 597: | /** @var \Illuminate\Foundation\Application $instance */ |
| 598: | return $instance->shouldSkipMiddleware(); |
| 599: | } |
| 600: | /** |
| 601: | * Get the path to the cached services.php file. |
| 602: | * |
| 603: | * @return string |
| 604: | * @static |
| 605: | */ |
| 606: | public static function getCachedServicesPath() |
| 607: | { |
| 608: | /** @var \Illuminate\Foundation\Application $instance */ |
| 609: | return $instance->getCachedServicesPath(); |
| 610: | } |
| 611: | /** |
| 612: | * Get the path to the cached packages.php file. |
| 613: | * |
| 614: | * @return string |
| 615: | * @static |
| 616: | */ |
| 617: | public static function getCachedPackagesPath() |
| 618: | { |
| 619: | /** @var \Illuminate\Foundation\Application $instance */ |
| 620: | return $instance->getCachedPackagesPath(); |
| 621: | } |
| 622: | /** |
| 623: | * Determine if the application configuration is cached. |
| 624: | * |
| 625: | * @return bool |
| 626: | * @static |
| 627: | */ |
| 628: | public static function configurationIsCached() |
| 629: | { |
| 630: | /** @var \Illuminate\Foundation\Application $instance */ |
| 631: | return $instance->configurationIsCached(); |
| 632: | } |
| 633: | /** |
| 634: | * Get the path to the configuration cache file. |
| 635: | * |
| 636: | * @return string |
| 637: | * @static |
| 638: | */ |
| 639: | public static function getCachedConfigPath() |
| 640: | { |
| 641: | /** @var \Illuminate\Foundation\Application $instance */ |
| 642: | return $instance->getCachedConfigPath(); |
| 643: | } |
| 644: | /** |
| 645: | * Determine if the application routes are cached. |
| 646: | * |
| 647: | * @return bool |
| 648: | * @static |
| 649: | */ |
| 650: | public static function routesAreCached() |
| 651: | { |
| 652: | /** @var \Illuminate\Foundation\Application $instance */ |
| 653: | return $instance->routesAreCached(); |
| 654: | } |
| 655: | /** |
| 656: | * Get the path to the routes cache file. |
| 657: | * |
| 658: | * @return string |
| 659: | * @static |
| 660: | */ |
| 661: | public static function getCachedRoutesPath() |
| 662: | { |
| 663: | /** @var \Illuminate\Foundation\Application $instance */ |
| 664: | return $instance->getCachedRoutesPath(); |
| 665: | } |
| 666: | /** |
| 667: | * Determine if the application events are cached. |
| 668: | * |
| 669: | * @return bool |
| 670: | * @static |
| 671: | */ |
| 672: | public static function eventsAreCached() |
| 673: | { |
| 674: | /** @var \Illuminate\Foundation\Application $instance */ |
| 675: | return $instance->eventsAreCached(); |
| 676: | } |
| 677: | /** |
| 678: | * Get the path to the events cache file. |
| 679: | * |
| 680: | * @return string |
| 681: | * @static |
| 682: | */ |
| 683: | public static function getCachedEventsPath() |
| 684: | { |
| 685: | /** @var \Illuminate\Foundation\Application $instance */ |
| 686: | return $instance->getCachedEventsPath(); |
| 687: | } |
| 688: | /** |
| 689: | * Add new prefix to list of absolute path prefixes. |
| 690: | * |
| 691: | * @param string $prefix |
| 692: | * @return \Illuminate\Foundation\Application |
| 693: | * @static |
| 694: | */ |
| 695: | public static function addAbsoluteCachePathPrefix($prefix) |
| 696: | { |
| 697: | /** @var \Illuminate\Foundation\Application $instance */ |
| 698: | return $instance->addAbsoluteCachePathPrefix($prefix); |
| 699: | } |
| 700: | /** |
| 701: | * Get an instance of the maintenance mode manager implementation. |
| 702: | * |
| 703: | * @return \Illuminate\Contracts\Foundation\MaintenanceMode |
| 704: | * @static |
| 705: | */ |
| 706: | public static function maintenanceMode() |
| 707: | { |
| 708: | /** @var \Illuminate\Foundation\Application $instance */ |
| 709: | return $instance->maintenanceMode(); |
| 710: | } |
| 711: | /** |
| 712: | * Determine if the application is currently down for maintenance. |
| 713: | * |
| 714: | * @return bool |
| 715: | * @static |
| 716: | */ |
| 717: | public static function isDownForMaintenance() |
| 718: | { |
| 719: | /** @var \Illuminate\Foundation\Application $instance */ |
| 720: | return $instance->isDownForMaintenance(); |
| 721: | } |
| 722: | /** |
| 723: | * Throw an HttpException with the given data. |
| 724: | * |
| 725: | * @param int $code |
| 726: | * @param string $message |
| 727: | * @param array $headers |
| 728: | * @return \Illuminate\Foundation\never |
| 729: | * @throws \Symfony\Component\HttpKernel\Exception\HttpException |
| 730: | * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException |
| 731: | * @static |
| 732: | */ |
| 733: | public static function abort($code, $message = '', $headers = []) |
| 734: | { |
| 735: | /** @var \Illuminate\Foundation\Application $instance */ |
| 736: | return $instance->abort($code, $message, $headers); |
| 737: | } |
| 738: | /** |
| 739: | * Register a terminating callback with the application. |
| 740: | * |
| 741: | * @param callable|string $callback |
| 742: | * @return \Illuminate\Foundation\Application |
| 743: | * @static |
| 744: | */ |
| 745: | public static function terminating($callback) |
| 746: | { |
| 747: | /** @var \Illuminate\Foundation\Application $instance */ |
| 748: | return $instance->terminating($callback); |
| 749: | } |
| 750: | /** |
| 751: | * Terminate the application. |
| 752: | * |
| 753: | * @return void |
| 754: | * @static |
| 755: | */ |
| 756: | public static function terminate() |
| 757: | { |
| 758: | /** @var \Illuminate\Foundation\Application $instance */ |
| 759: | $instance->terminate(); |
| 760: | } |
| 761: | /** |
| 762: | * Get the service providers that have been loaded. |
| 763: | * |
| 764: | * @return array |
| 765: | * @static |
| 766: | */ |
| 767: | public static function getLoadedProviders() |
| 768: | { |
| 769: | /** @var \Illuminate\Foundation\Application $instance */ |
| 770: | return $instance->getLoadedProviders(); |
| 771: | } |
| 772: | /** |
| 773: | * Determine if the given service provider is loaded. |
| 774: | * |
| 775: | * @param string $provider |
| 776: | * @return bool |
| 777: | * @static |
| 778: | */ |
| 779: | public static function providerIsLoaded($provider) |
| 780: | { |
| 781: | /** @var \Illuminate\Foundation\Application $instance */ |
| 782: | return $instance->providerIsLoaded($provider); |
| 783: | } |
| 784: | /** |
| 785: | * Get the application's deferred services. |
| 786: | * |
| 787: | * @return array |
| 788: | * @static |
| 789: | */ |
| 790: | public static function getDeferredServices() |
| 791: | { |
| 792: | /** @var \Illuminate\Foundation\Application $instance */ |
| 793: | return $instance->getDeferredServices(); |
| 794: | } |
| 795: | /** |
| 796: | * Set the application's deferred services. |
| 797: | * |
| 798: | * @param array $services |
| 799: | * @return void |
| 800: | * @static |
| 801: | */ |
| 802: | public static function setDeferredServices($services) |
| 803: | { |
| 804: | /** @var \Illuminate\Foundation\Application $instance */ |
| 805: | $instance->setDeferredServices($services); |
| 806: | } |
| 807: | /** |
| 808: | * Add an array of services to the application's deferred services. |
| 809: | * |
| 810: | * @param array $services |
| 811: | * @return void |
| 812: | * @static |
| 813: | */ |
| 814: | public static function addDeferredServices($services) |
| 815: | { |
| 816: | /** @var \Illuminate\Foundation\Application $instance */ |
| 817: | $instance->addDeferredServices($services); |
| 818: | } |
| 819: | /** |
| 820: | * Determine if the given service is a deferred service. |
| 821: | * |
| 822: | * @param string $service |
| 823: | * @return bool |
| 824: | * @static |
| 825: | */ |
| 826: | public static function isDeferredService($service) |
| 827: | { |
| 828: | /** @var \Illuminate\Foundation\Application $instance */ |
| 829: | return $instance->isDeferredService($service); |
| 830: | } |
| 831: | /** |
| 832: | * Configure the real-time facade namespace. |
| 833: | * |
| 834: | * @param string $namespace |
| 835: | * @return void |
| 836: | * @static |
| 837: | */ |
| 838: | public static function provideFacades($namespace) |
| 839: | { |
| 840: | /** @var \Illuminate\Foundation\Application $instance */ |
| 841: | $instance->provideFacades($namespace); |
| 842: | } |
| 843: | /** |
| 844: | * Get the current application locale. |
| 845: | * |
| 846: | * @return string |
| 847: | * @static |
| 848: | */ |
| 849: | public static function getLocale() |
| 850: | { |
| 851: | /** @var \Illuminate\Foundation\Application $instance */ |
| 852: | return $instance->getLocale(); |
| 853: | } |
| 854: | /** |
| 855: | * Get the current application locale. |
| 856: | * |
| 857: | * @return string |
| 858: | * @static |
| 859: | */ |
| 860: | public static function currentLocale() |
| 861: | { |
| 862: | /** @var \Illuminate\Foundation\Application $instance */ |
| 863: | return $instance->currentLocale(); |
| 864: | } |
| 865: | /** |
| 866: | * Get the current application fallback locale. |
| 867: | * |
| 868: | * @return string |
| 869: | * @static |
| 870: | */ |
| 871: | public static function getFallbackLocale() |
| 872: | { |
| 873: | /** @var \Illuminate\Foundation\Application $instance */ |
| 874: | return $instance->getFallbackLocale(); |
| 875: | } |
| 876: | /** |
| 877: | * Set the current application locale. |
| 878: | * |
| 879: | * @param string $locale |
| 880: | * @return void |
| 881: | * @static |
| 882: | */ |
| 883: | public static function setLocale($locale) |
| 884: | { |
| 885: | /** @var \Illuminate\Foundation\Application $instance */ |
| 886: | $instance->setLocale($locale); |
| 887: | } |
| 888: | /** |
| 889: | * Set the current application fallback locale. |
| 890: | * |
| 891: | * @param string $fallbackLocale |
| 892: | * @return void |
| 893: | * @static |
| 894: | */ |
| 895: | public static function setFallbackLocale($fallbackLocale) |
| 896: | { |
| 897: | /** @var \Illuminate\Foundation\Application $instance */ |
| 898: | $instance->setFallbackLocale($fallbackLocale); |
| 899: | } |
| 900: | /** |
| 901: | * Determine if the application locale is the given locale. |
| 902: | * |
| 903: | * @param string $locale |
| 904: | * @return bool |
| 905: | * @static |
| 906: | */ |
| 907: | public static function isLocale($locale) |
| 908: | { |
| 909: | /** @var \Illuminate\Foundation\Application $instance */ |
| 910: | return $instance->isLocale($locale); |
| 911: | } |
| 912: | /** |
| 913: | * Register the core class aliases in the container. |
| 914: | * |
| 915: | * @return void |
| 916: | * @static |
| 917: | */ |
| 918: | public static function registerCoreContainerAliases() |
| 919: | { |
| 920: | /** @var \Illuminate\Foundation\Application $instance */ |
| 921: | $instance->registerCoreContainerAliases(); |
| 922: | } |
| 923: | /** |
| 924: | * Flush the container of all bindings and resolved instances. |
| 925: | * |
| 926: | * @return void |
| 927: | * @static |
| 928: | */ |
| 929: | public static function flush() |
| 930: | { |
| 931: | /** @var \Illuminate\Foundation\Application $instance */ |
| 932: | $instance->flush(); |
| 933: | } |
| 934: | /** |
| 935: | * Get the application namespace. |
| 936: | * |
| 937: | * @return string |
| 938: | * @throws \RuntimeException |
| 939: | * @static |
| 940: | */ |
| 941: | public static function getNamespace() |
| 942: | { |
| 943: | /** @var \Illuminate\Foundation\Application $instance */ |
| 944: | return $instance->getNamespace(); |
| 945: | } |
| 946: | /** |
| 947: | * Define a contextual binding. |
| 948: | * |
| 949: | * @param array|string $concrete |
| 950: | * @return \Illuminate\Contracts\Container\ContextualBindingBuilder |
| 951: | * @static |
| 952: | */ |
| 953: | public static function when($concrete) |
| 954: | { //Method inherited from \Illuminate\Container\Container |
| 955: | /** @var \Illuminate\Foundation\Application $instance */ |
| 956: | return $instance->when($concrete); |
| 957: | } |
| 958: | /** |
| 959: | * Returns true if the container can return an entry for the given identifier. |
| 960: | * |
| 961: | * Returns false otherwise. |
| 962: | * |
| 963: | * `has($id)` returning true does not mean that `get($id)` will not throw an exception. |
| 964: | * It does however mean that `get($id)` will not throw a `NotFoundExceptionInterface`. |
| 965: | * |
| 966: | * @return bool |
| 967: | * @param string $id Identifier of the entry to look for. |
| 968: | * @return bool |
| 969: | * @static |
| 970: | */ |
| 971: | public static function has($id) |
| 972: | { //Method inherited from \Illuminate\Container\Container |
| 973: | /** @var \Illuminate\Foundation\Application $instance */ |
| 974: | return $instance->has($id); |
| 975: | } |
| 976: | /** |
| 977: | * Determine if the given abstract type has been resolved. |
| 978: | * |
| 979: | * @param string $abstract |
| 980: | * @return bool |
| 981: | * @static |
| 982: | */ |
| 983: | public static function resolved($abstract) |
| 984: | { //Method inherited from \Illuminate\Container\Container |
| 985: | /** @var \Illuminate\Foundation\Application $instance */ |
| 986: | return $instance->resolved($abstract); |
| 987: | } |
| 988: | /** |
| 989: | * Determine if a given type is shared. |
| 990: | * |
| 991: | * @param string $abstract |
| 992: | * @return bool |
| 993: | * @static |
| 994: | */ |
| 995: | public static function isShared($abstract) |
| 996: | { //Method inherited from \Illuminate\Container\Container |
| 997: | /** @var \Illuminate\Foundation\Application $instance */ |
| 998: | return $instance->isShared($abstract); |
| 999: | } |
| 1000: | /** |
| 1001: | * Determine if a given string is an alias. |
| 1002: | * |
| 1003: | * @param string $name |
| 1004: | * @return bool |
| 1005: | * @static |
| 1006: | */ |
| 1007: | public static function isAlias($name) |
| 1008: | { //Method inherited from \Illuminate\Container\Container |
| 1009: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1010: | return $instance->isAlias($name); |
| 1011: | } |
| 1012: | /** |
| 1013: | * Register a binding with the container. |
| 1014: | * |
| 1015: | * @param string $abstract |
| 1016: | * @param \Closure|string|null $concrete |
| 1017: | * @param bool $shared |
| 1018: | * @return void |
| 1019: | * @throws \TypeError |
| 1020: | * @static |
| 1021: | */ |
| 1022: | public static function bind($abstract, $concrete = null, $shared = false) |
| 1023: | { //Method inherited from \Illuminate\Container\Container |
| 1024: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1025: | $instance->bind($abstract, $concrete, $shared); |
| 1026: | } |
| 1027: | /** |
| 1028: | * Determine if the container has a method binding. |
| 1029: | * |
| 1030: | * @param string $method |
| 1031: | * @return bool |
| 1032: | * @static |
| 1033: | */ |
| 1034: | public static function hasMethodBinding($method) |
| 1035: | { //Method inherited from \Illuminate\Container\Container |
| 1036: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1037: | return $instance->hasMethodBinding($method); |
| 1038: | } |
| 1039: | /** |
| 1040: | * Bind a callback to resolve with Container::call. |
| 1041: | * |
| 1042: | * @param array|string $method |
| 1043: | * @param \Closure $callback |
| 1044: | * @return void |
| 1045: | * @static |
| 1046: | */ |
| 1047: | public static function bindMethod($method, $callback) |
| 1048: | { //Method inherited from \Illuminate\Container\Container |
| 1049: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1050: | $instance->bindMethod($method, $callback); |
| 1051: | } |
| 1052: | /** |
| 1053: | * Get the method binding for the given method. |
| 1054: | * |
| 1055: | * @param string $method |
| 1056: | * @param mixed $instance |
| 1057: | * @return mixed |
| 1058: | * @static |
| 1059: | */ |
| 1060: | public static function callMethodBinding($method, $instance) |
| 1061: | { //Method inherited from \Illuminate\Container\Container |
| 1062: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1063: | return $instance->callMethodBinding($method, $instance); |
| 1064: | } |
| 1065: | /** |
| 1066: | * Add a contextual binding to the container. |
| 1067: | * |
| 1068: | * @param string $concrete |
| 1069: | * @param string $abstract |
| 1070: | * @param \Closure|string $implementation |
| 1071: | * @return void |
| 1072: | * @static |
| 1073: | */ |
| 1074: | public static function addContextualBinding($concrete, $abstract, $implementation) |
| 1075: | { //Method inherited from \Illuminate\Container\Container |
| 1076: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1077: | $instance->addContextualBinding($concrete, $abstract, $implementation); |
| 1078: | } |
| 1079: | /** |
| 1080: | * Register a binding if it hasn't already been registered. |
| 1081: | * |
| 1082: | * @param string $abstract |
| 1083: | * @param \Closure|string|null $concrete |
| 1084: | * @param bool $shared |
| 1085: | * @return void |
| 1086: | * @static |
| 1087: | */ |
| 1088: | public static function bindIf($abstract, $concrete = null, $shared = false) |
| 1089: | { //Method inherited from \Illuminate\Container\Container |
| 1090: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1091: | $instance->bindIf($abstract, $concrete, $shared); |
| 1092: | } |
| 1093: | /** |
| 1094: | * Register a shared binding in the container. |
| 1095: | * |
| 1096: | * @param string $abstract |
| 1097: | * @param \Closure|string|null $concrete |
| 1098: | * @return void |
| 1099: | * @static |
| 1100: | */ |
| 1101: | public static function singleton($abstract, $concrete = null) |
| 1102: | { //Method inherited from \Illuminate\Container\Container |
| 1103: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1104: | $instance->singleton($abstract, $concrete); |
| 1105: | } |
| 1106: | /** |
| 1107: | * Register a shared binding if it hasn't already been registered. |
| 1108: | * |
| 1109: | * @param string $abstract |
| 1110: | * @param \Closure|string|null $concrete |
| 1111: | * @return void |
| 1112: | * @static |
| 1113: | */ |
| 1114: | public static function singletonIf($abstract, $concrete = null) |
| 1115: | { //Method inherited from \Illuminate\Container\Container |
| 1116: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1117: | $instance->singletonIf($abstract, $concrete); |
| 1118: | } |
| 1119: | /** |
| 1120: | * Register a scoped binding in the container. |
| 1121: | * |
| 1122: | * @param string $abstract |
| 1123: | * @param \Closure|string|null $concrete |
| 1124: | * @return void |
| 1125: | * @static |
| 1126: | */ |
| 1127: | public static function scoped($abstract, $concrete = null) |
| 1128: | { //Method inherited from \Illuminate\Container\Container |
| 1129: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1130: | $instance->scoped($abstract, $concrete); |
| 1131: | } |
| 1132: | /** |
| 1133: | * Register a scoped binding if it hasn't already been registered. |
| 1134: | * |
| 1135: | * @param string $abstract |
| 1136: | * @param \Closure|string|null $concrete |
| 1137: | * @return void |
| 1138: | * @static |
| 1139: | */ |
| 1140: | public static function scopedIf($abstract, $concrete = null) |
| 1141: | { //Method inherited from \Illuminate\Container\Container |
| 1142: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1143: | $instance->scopedIf($abstract, $concrete); |
| 1144: | } |
| 1145: | /** |
| 1146: | * "Extend" an abstract type in the container. |
| 1147: | * |
| 1148: | * @param string $abstract |
| 1149: | * @param \Closure $closure |
| 1150: | * @return void |
| 1151: | * @throws \InvalidArgumentException |
| 1152: | * @static |
| 1153: | */ |
| 1154: | public static function extend($abstract, $closure) |
| 1155: | { //Method inherited from \Illuminate\Container\Container |
| 1156: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1157: | $instance->extend($abstract, $closure); |
| 1158: | } |
| 1159: | /** |
| 1160: | * Register an existing instance as shared in the container. |
| 1161: | * |
| 1162: | * @param string $abstract |
| 1163: | * @param mixed $instance |
| 1164: | * @return mixed |
| 1165: | * @static |
| 1166: | */ |
| 1167: | public static function instance($abstract, $instance) |
| 1168: | { //Method inherited from \Illuminate\Container\Container |
| 1169: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1170: | return $instance->instance($abstract, $instance); |
| 1171: | } |
| 1172: | /** |
| 1173: | * Assign a set of tags to a given binding. |
| 1174: | * |
| 1175: | * @param array|string $abstracts |
| 1176: | * @param array|mixed $tags |
| 1177: | * @return void |
| 1178: | * @static |
| 1179: | */ |
| 1180: | public static function tag($abstracts, $tags) |
| 1181: | { //Method inherited from \Illuminate\Container\Container |
| 1182: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1183: | $instance->tag($abstracts, $tags); |
| 1184: | } |
| 1185: | /** |
| 1186: | * Resolve all of the bindings for a given tag. |
| 1187: | * |
| 1188: | * @param string $tag |
| 1189: | * @return \Illuminate\Container\iterable |
| 1190: | * @static |
| 1191: | */ |
| 1192: | public static function tagged($tag) |
| 1193: | { //Method inherited from \Illuminate\Container\Container |
| 1194: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1195: | return $instance->tagged($tag); |
| 1196: | } |
| 1197: | /** |
| 1198: | * Alias a type to a different name. |
| 1199: | * |
| 1200: | * @param string $abstract |
| 1201: | * @param string $alias |
| 1202: | * @return void |
| 1203: | * @throws \LogicException |
| 1204: | * @static |
| 1205: | */ |
| 1206: | public static function alias($abstract, $alias) |
| 1207: | { //Method inherited from \Illuminate\Container\Container |
| 1208: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1209: | $instance->alias($abstract, $alias); |
| 1210: | } |
| 1211: | /** |
| 1212: | * Bind a new callback to an abstract's rebind event. |
| 1213: | * |
| 1214: | * @param string $abstract |
| 1215: | * @param \Closure $callback |
| 1216: | * @return mixed |
| 1217: | * @static |
| 1218: | */ |
| 1219: | public static function rebinding($abstract, $callback) |
| 1220: | { //Method inherited from \Illuminate\Container\Container |
| 1221: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1222: | return $instance->rebinding($abstract, $callback); |
| 1223: | } |
| 1224: | /** |
| 1225: | * Refresh an instance on the given target and method. |
| 1226: | * |
| 1227: | * @param string $abstract |
| 1228: | * @param mixed $target |
| 1229: | * @param string $method |
| 1230: | * @return mixed |
| 1231: | * @static |
| 1232: | */ |
| 1233: | public static function refresh($abstract, $target, $method) |
| 1234: | { //Method inherited from \Illuminate\Container\Container |
| 1235: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1236: | return $instance->refresh($abstract, $target, $method); |
| 1237: | } |
| 1238: | /** |
| 1239: | * Wrap the given closure such that its dependencies will be injected when executed. |
| 1240: | * |
| 1241: | * @param \Closure $callback |
| 1242: | * @param array $parameters |
| 1243: | * @return \Closure |
| 1244: | * @static |
| 1245: | */ |
| 1246: | public static function wrap($callback, $parameters = []) |
| 1247: | { //Method inherited from \Illuminate\Container\Container |
| 1248: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1249: | return $instance->wrap($callback, $parameters); |
| 1250: | } |
| 1251: | /** |
| 1252: | * Call the given Closure / class@method and inject its dependencies. |
| 1253: | * |
| 1254: | * @param callable|string $callback |
| 1255: | * @param \Illuminate\Container\array<string, mixed> $parameters |
| 1256: | * @param string|null $defaultMethod |
| 1257: | * @return mixed |
| 1258: | * @throws \InvalidArgumentException |
| 1259: | * @static |
| 1260: | */ |
| 1261: | public static function call($callback, $parameters = [], $defaultMethod = null) |
| 1262: | { //Method inherited from \Illuminate\Container\Container |
| 1263: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1264: | return $instance->call($callback, $parameters, $defaultMethod); |
| 1265: | } |
| 1266: | /** |
| 1267: | * Get a closure to resolve the given type from the container. |
| 1268: | * |
| 1269: | * @param string $abstract |
| 1270: | * @return \Closure |
| 1271: | * @static |
| 1272: | */ |
| 1273: | public static function factory($abstract) |
| 1274: | { //Method inherited from \Illuminate\Container\Container |
| 1275: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1276: | return $instance->factory($abstract); |
| 1277: | } |
| 1278: | /** |
| 1279: | * An alias function name for make(). |
| 1280: | * |
| 1281: | * @param string|callable $abstract |
| 1282: | * @param array $parameters |
| 1283: | * @return mixed |
| 1284: | * @throws \Illuminate\Contracts\Container\BindingResolutionException |
| 1285: | * @static |
| 1286: | */ |
| 1287: | public static function makeWith($abstract, $parameters = []) |
| 1288: | { //Method inherited from \Illuminate\Container\Container |
| 1289: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1290: | return $instance->makeWith($abstract, $parameters); |
| 1291: | } |
| 1292: | /** |
| 1293: | * Finds an entry of the container by its identifier and returns it. |
| 1294: | * |
| 1295: | * @return mixed |
| 1296: | * @param string $id Identifier of the entry to look for. |
| 1297: | * @throws NotFoundExceptionInterface No entry was found for **this** identifier. |
| 1298: | * @throws ContainerExceptionInterface Error while retrieving the entry. |
| 1299: | * @return mixed Entry. |
| 1300: | * @static |
| 1301: | */ |
| 1302: | public static function get($id) |
| 1303: | { //Method inherited from \Illuminate\Container\Container |
| 1304: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1305: | return $instance->get($id); |
| 1306: | } |
| 1307: | /** |
| 1308: | * Instantiate a concrete instance of the given type. |
| 1309: | * |
| 1310: | * @param \Closure|string $concrete |
| 1311: | * @return mixed |
| 1312: | * @throws \Illuminate\Contracts\Container\BindingResolutionException |
| 1313: | * @throws \Illuminate\Contracts\Container\CircularDependencyException |
| 1314: | * @static |
| 1315: | */ |
| 1316: | public static function build($concrete) |
| 1317: | { //Method inherited from \Illuminate\Container\Container |
| 1318: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1319: | return $instance->build($concrete); |
| 1320: | } |
| 1321: | /** |
| 1322: | * Register a new before resolving callback for all types. |
| 1323: | * |
| 1324: | * @param \Closure|string $abstract |
| 1325: | * @param \Closure|null $callback |
| 1326: | * @return void |
| 1327: | * @static |
| 1328: | */ |
| 1329: | public static function beforeResolving($abstract, $callback = null) |
| 1330: | { //Method inherited from \Illuminate\Container\Container |
| 1331: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1332: | $instance->beforeResolving($abstract, $callback); |
| 1333: | } |
| 1334: | /** |
| 1335: | * Register a new resolving callback. |
| 1336: | * |
| 1337: | * @param \Closure|string $abstract |
| 1338: | * @param \Closure|null $callback |
| 1339: | * @return void |
| 1340: | * @static |
| 1341: | */ |
| 1342: | public static function resolving($abstract, $callback = null) |
| 1343: | { //Method inherited from \Illuminate\Container\Container |
| 1344: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1345: | $instance->resolving($abstract, $callback); |
| 1346: | } |
| 1347: | /** |
| 1348: | * Register a new after resolving callback for all types. |
| 1349: | * |
| 1350: | * @param \Closure|string $abstract |
| 1351: | * @param \Closure|null $callback |
| 1352: | * @return void |
| 1353: | * @static |
| 1354: | */ |
| 1355: | public static function afterResolving($abstract, $callback = null) |
| 1356: | { //Method inherited from \Illuminate\Container\Container |
| 1357: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1358: | $instance->afterResolving($abstract, $callback); |
| 1359: | } |
| 1360: | /** |
| 1361: | * Get the container's bindings. |
| 1362: | * |
| 1363: | * @return array |
| 1364: | * @static |
| 1365: | */ |
| 1366: | public static function getBindings() |
| 1367: | { //Method inherited from \Illuminate\Container\Container |
| 1368: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1369: | return $instance->getBindings(); |
| 1370: | } |
| 1371: | /** |
| 1372: | * Get the alias for an abstract if available. |
| 1373: | * |
| 1374: | * @param string $abstract |
| 1375: | * @return string |
| 1376: | * @static |
| 1377: | */ |
| 1378: | public static function getAlias($abstract) |
| 1379: | { //Method inherited from \Illuminate\Container\Container |
| 1380: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1381: | return $instance->getAlias($abstract); |
| 1382: | } |
| 1383: | /** |
| 1384: | * Remove all of the extender callbacks for a given type. |
| 1385: | * |
| 1386: | * @param string $abstract |
| 1387: | * @return void |
| 1388: | * @static |
| 1389: | */ |
| 1390: | public static function forgetExtenders($abstract) |
| 1391: | { //Method inherited from \Illuminate\Container\Container |
| 1392: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1393: | $instance->forgetExtenders($abstract); |
| 1394: | } |
| 1395: | /** |
| 1396: | * Remove a resolved instance from the instance cache. |
| 1397: | * |
| 1398: | * @param string $abstract |
| 1399: | * @return void |
| 1400: | * @static |
| 1401: | */ |
| 1402: | public static function forgetInstance($abstract) |
| 1403: | { //Method inherited from \Illuminate\Container\Container |
| 1404: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1405: | $instance->forgetInstance($abstract); |
| 1406: | } |
| 1407: | /** |
| 1408: | * Clear all of the instances from the container. |
| 1409: | * |
| 1410: | * @return void |
| 1411: | * @static |
| 1412: | */ |
| 1413: | public static function forgetInstances() |
| 1414: | { //Method inherited from \Illuminate\Container\Container |
| 1415: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1416: | $instance->forgetInstances(); |
| 1417: | } |
| 1418: | /** |
| 1419: | * Clear all of the scoped instances from the container. |
| 1420: | * |
| 1421: | * @return void |
| 1422: | * @static |
| 1423: | */ |
| 1424: | public static function forgetScopedInstances() |
| 1425: | { //Method inherited from \Illuminate\Container\Container |
| 1426: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1427: | $instance->forgetScopedInstances(); |
| 1428: | } |
| 1429: | /** |
| 1430: | * Get the globally available instance of the container. |
| 1431: | * |
| 1432: | * @return static |
| 1433: | * @static |
| 1434: | */ |
| 1435: | public static function getInstance() |
| 1436: | { //Method inherited from \Illuminate\Container\Container |
| 1437: | return \Illuminate\Foundation\Application::getInstance(); |
| 1438: | } |
| 1439: | /** |
| 1440: | * Set the shared instance of the container. |
| 1441: | * |
| 1442: | * @param \Illuminate\Contracts\Container\Container|null $container |
| 1443: | * @return \Illuminate\Contracts\Container\Container|static |
| 1444: | * @static |
| 1445: | */ |
| 1446: | public static function setInstance($container = null) |
| 1447: | { //Method inherited from \Illuminate\Container\Container |
| 1448: | return \Illuminate\Foundation\Application::setInstance($container); |
| 1449: | } |
| 1450: | /** |
| 1451: | * Determine if a given offset exists. |
| 1452: | * |
| 1453: | * @param string $key |
| 1454: | * @return bool |
| 1455: | * @static |
| 1456: | */ |
| 1457: | public static function offsetExists($key) |
| 1458: | { //Method inherited from \Illuminate\Container\Container |
| 1459: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1460: | return $instance->offsetExists($key); |
| 1461: | } |
| 1462: | /** |
| 1463: | * Get the value at a given offset. |
| 1464: | * |
| 1465: | * @param string $key |
| 1466: | * @return mixed |
| 1467: | * @static |
| 1468: | */ |
| 1469: | public static function offsetGet($key) |
| 1470: | { //Method inherited from \Illuminate\Container\Container |
| 1471: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1472: | return $instance->offsetGet($key); |
| 1473: | } |
| 1474: | /** |
| 1475: | * Set the value at a given offset. |
| 1476: | * |
| 1477: | * @param string $key |
| 1478: | * @param mixed $value |
| 1479: | * @return void |
| 1480: | * @static |
| 1481: | */ |
| 1482: | public static function offsetSet($key, $value) |
| 1483: | { //Method inherited from \Illuminate\Container\Container |
| 1484: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1485: | $instance->offsetSet($key, $value); |
| 1486: | } |
| 1487: | /** |
| 1488: | * Unset the value at a given offset. |
| 1489: | * |
| 1490: | * @param string $key |
| 1491: | * @return void |
| 1492: | * @static |
| 1493: | */ |
| 1494: | public static function offsetUnset($key) |
| 1495: | { //Method inherited from \Illuminate\Container\Container |
| 1496: | /** @var \Illuminate\Foundation\Application $instance */ |
| 1497: | $instance->offsetUnset($key); |
| 1498: | } |
| 1499: | |
| 1500: | } |
| 1501: | /** |
| 1502: | * |
| 1503: | * |
| 1504: | * @see \Illuminate\Contracts\Console\Kernel |
| 1505: | */ |
| 1506: | class Artisan { |
| 1507: | /** |
| 1508: | * Run the console application. |
| 1509: | * |
| 1510: | * @param \Symfony\Component\Console\Input\InputInterface $input |
| 1511: | * @param \Symfony\Component\Console\Output\OutputInterface|null $output |
| 1512: | * @return int |
| 1513: | * @static |
| 1514: | */ |
| 1515: | public static function handle($input, $output = null) |
| 1516: | { //Method inherited from \Illuminate\Foundation\Console\Kernel |
| 1517: | /** @var \App\Console\Kernel $instance */ |
| 1518: | return $instance->handle($input, $output); |
| 1519: | } |
| 1520: | /** |
| 1521: | * Terminate the application. |
| 1522: | * |
| 1523: | * @param \Symfony\Component\Console\Input\InputInterface $input |
| 1524: | * @param int $status |
| 1525: | * @return void |
| 1526: | * @static |
| 1527: | */ |
| 1528: | public static function terminate($input, $status) |
| 1529: | { //Method inherited from \Illuminate\Foundation\Console\Kernel |
| 1530: | /** @var \App\Console\Kernel $instance */ |
| 1531: | $instance->terminate($input, $status); |
| 1532: | } |
| 1533: | /** |
| 1534: | * Register a Closure based command with the application. |
| 1535: | * |
| 1536: | * @param string $signature |
| 1537: | * @param \Closure $callback |
| 1538: | * @return \Illuminate\Foundation\Console\ClosureCommand |
| 1539: | * @static |
| 1540: | */ |
| 1541: | public static function command($signature, $callback) |
| 1542: | { //Method inherited from \Illuminate\Foundation\Console\Kernel |
| 1543: | /** @var \App\Console\Kernel $instance */ |
| 1544: | return $instance->command($signature, $callback); |
| 1545: | } |
| 1546: | /** |
| 1547: | * Register the given command with the console application. |
| 1548: | * |
| 1549: | * @param \Symfony\Component\Console\Command\Command $command |
| 1550: | * @return void |
| 1551: | * @static |
| 1552: | */ |
| 1553: | public static function registerCommand($command) |
| 1554: | { //Method inherited from \Illuminate\Foundation\Console\Kernel |
| 1555: | /** @var \App\Console\Kernel $instance */ |
| 1556: | $instance->registerCommand($command); |
| 1557: | } |
| 1558: | /** |
| 1559: | * Run an Artisan console command by name. |
| 1560: | * |
| 1561: | * @param string $command |
| 1562: | * @param array $parameters |
| 1563: | * @param \Symfony\Component\Console\Output\OutputInterface|null $outputBuffer |
| 1564: | * @return int |
| 1565: | * @throws \Symfony\Component\Console\Exception\CommandNotFoundException |
| 1566: | * @static |
| 1567: | */ |
| 1568: | public static function call($command, $parameters = [], $outputBuffer = null) |
| 1569: | { //Method inherited from \Illuminate\Foundation\Console\Kernel |
| 1570: | /** @var \App\Console\Kernel $instance */ |
| 1571: | return $instance->call($command, $parameters, $outputBuffer); |
| 1572: | } |
| 1573: | /** |
| 1574: | * Queue the given console command. |
| 1575: | * |
| 1576: | * @param string $command |
| 1577: | * @param array $parameters |
| 1578: | * @return \Illuminate\Foundation\Bus\PendingDispatch |
| 1579: | * @static |
| 1580: | */ |
| 1581: | public static function queue($command, $parameters = []) |
| 1582: | { //Method inherited from \Illuminate\Foundation\Console\Kernel |
| 1583: | /** @var \App\Console\Kernel $instance */ |
| 1584: | return $instance->queue($command, $parameters); |
| 1585: | } |
| 1586: | /** |
| 1587: | * Get all of the commands registered with the console. |
| 1588: | * |
| 1589: | * @return array |
| 1590: | * @static |
| 1591: | */ |
| 1592: | public static function all() |
| 1593: | { //Method inherited from \Illuminate\Foundation\Console\Kernel |
| 1594: | /** @var \App\Console\Kernel $instance */ |
| 1595: | return $instance->all(); |
| 1596: | } |
| 1597: | /** |
| 1598: | * Get the output for the last run command. |
| 1599: | * |
| 1600: | * @return string |
| 1601: | * @static |
| 1602: | */ |
| 1603: | public static function output() |
| 1604: | { //Method inherited from \Illuminate\Foundation\Console\Kernel |
| 1605: | /** @var \App\Console\Kernel $instance */ |
| 1606: | return $instance->output(); |
| 1607: | } |
| 1608: | /** |
| 1609: | * Bootstrap the application for artisan commands. |
| 1610: | * |
| 1611: | * @return void |
| 1612: | * @static |
| 1613: | */ |
| 1614: | public static function bootstrap() |
| 1615: | { //Method inherited from \Illuminate\Foundation\Console\Kernel |
| 1616: | /** @var \App\Console\Kernel $instance */ |
| 1617: | $instance->bootstrap(); |
| 1618: | } |
| 1619: | /** |
| 1620: | * Set the Artisan application instance. |
| 1621: | * |
| 1622: | * @param \Illuminate\Console\Application $artisan |
| 1623: | * @return void |
| 1624: | * @static |
| 1625: | */ |
| 1626: | public static function setArtisan($artisan) |
| 1627: | { //Method inherited from \Illuminate\Foundation\Console\Kernel |
| 1628: | /** @var \App\Console\Kernel $instance */ |
| 1629: | $instance->setArtisan($artisan); |
| 1630: | } |
| 1631: | |
| 1632: | } |
| 1633: | /** |
| 1634: | * |
| 1635: | * |
| 1636: | * @see \Illuminate\Auth\AuthManager |
| 1637: | * @see \Illuminate\Contracts\Auth\Factory |
| 1638: | * @see \Illuminate\Contracts\Auth\Guard |
| 1639: | * @see \Illuminate\Contracts\Auth\StatefulGuard |
| 1640: | */ |
| 1641: | class Auth { |
| 1642: | /** |
| 1643: | * Attempt to get the guard from the local cache. |
| 1644: | * |
| 1645: | * @param string|null $name |
| 1646: | * @return \Illuminate\Contracts\Auth\Guard|\Illuminate\Contracts\Auth\StatefulGuard |
| 1647: | * @static |
| 1648: | */ |
| 1649: | public static function guard($name = null) |
| 1650: | { |
| 1651: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1652: | return $instance->guard($name); |
| 1653: | } |
| 1654: | /** |
| 1655: | * Create a session based authentication guard. |
| 1656: | * |
| 1657: | * @param string $name |
| 1658: | * @param array $config |
| 1659: | * @return \Illuminate\Auth\SessionGuard |
| 1660: | * @static |
| 1661: | */ |
| 1662: | public static function createSessionDriver($name, $config) |
| 1663: | { |
| 1664: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1665: | return $instance->createSessionDriver($name, $config); |
| 1666: | } |
| 1667: | /** |
| 1668: | * Create a token based authentication guard. |
| 1669: | * |
| 1670: | * @param string $name |
| 1671: | * @param array $config |
| 1672: | * @return \Illuminate\Auth\TokenGuard |
| 1673: | * @static |
| 1674: | */ |
| 1675: | public static function createTokenDriver($name, $config) |
| 1676: | { |
| 1677: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1678: | return $instance->createTokenDriver($name, $config); |
| 1679: | } |
| 1680: | /** |
| 1681: | * Get the default authentication driver name. |
| 1682: | * |
| 1683: | * @return string |
| 1684: | * @static |
| 1685: | */ |
| 1686: | public static function getDefaultDriver() |
| 1687: | { |
| 1688: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1689: | return $instance->getDefaultDriver(); |
| 1690: | } |
| 1691: | /** |
| 1692: | * Set the default guard driver the factory should serve. |
| 1693: | * |
| 1694: | * @param string $name |
| 1695: | * @return void |
| 1696: | * @static |
| 1697: | */ |
| 1698: | public static function shouldUse($name) |
| 1699: | { |
| 1700: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1701: | $instance->shouldUse($name); |
| 1702: | } |
| 1703: | /** |
| 1704: | * Set the default authentication driver name. |
| 1705: | * |
| 1706: | * @param string $name |
| 1707: | * @return void |
| 1708: | * @static |
| 1709: | */ |
| 1710: | public static function setDefaultDriver($name) |
| 1711: | { |
| 1712: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1713: | $instance->setDefaultDriver($name); |
| 1714: | } |
| 1715: | /** |
| 1716: | * Register a new callback based request guard. |
| 1717: | * |
| 1718: | * @param string $driver |
| 1719: | * @param callable $callback |
| 1720: | * @return \Illuminate\Auth\AuthManager |
| 1721: | * @static |
| 1722: | */ |
| 1723: | public static function viaRequest($driver, $callback) |
| 1724: | { |
| 1725: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1726: | return $instance->viaRequest($driver, $callback); |
| 1727: | } |
| 1728: | /** |
| 1729: | * Get the user resolver callback. |
| 1730: | * |
| 1731: | * @return \Closure |
| 1732: | * @static |
| 1733: | */ |
| 1734: | public static function userResolver() |
| 1735: | { |
| 1736: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1737: | return $instance->userResolver(); |
| 1738: | } |
| 1739: | /** |
| 1740: | * Set the callback to be used to resolve users. |
| 1741: | * |
| 1742: | * @param \Closure $userResolver |
| 1743: | * @return \Illuminate\Auth\AuthManager |
| 1744: | * @static |
| 1745: | */ |
| 1746: | public static function resolveUsersUsing($userResolver) |
| 1747: | { |
| 1748: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1749: | return $instance->resolveUsersUsing($userResolver); |
| 1750: | } |
| 1751: | /** |
| 1752: | * Register a custom driver creator Closure. |
| 1753: | * |
| 1754: | * @param string $driver |
| 1755: | * @param \Closure $callback |
| 1756: | * @return \Illuminate\Auth\AuthManager |
| 1757: | * @static |
| 1758: | */ |
| 1759: | public static function extend($driver, $callback) |
| 1760: | { |
| 1761: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1762: | return $instance->extend($driver, $callback); |
| 1763: | } |
| 1764: | /** |
| 1765: | * Register a custom provider creator Closure. |
| 1766: | * |
| 1767: | * @param string $name |
| 1768: | * @param \Closure $callback |
| 1769: | * @return \Illuminate\Auth\AuthManager |
| 1770: | * @static |
| 1771: | */ |
| 1772: | public static function provider($name, $callback) |
| 1773: | { |
| 1774: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1775: | return $instance->provider($name, $callback); |
| 1776: | } |
| 1777: | /** |
| 1778: | * Determines if any guards have already been resolved. |
| 1779: | * |
| 1780: | * @return bool |
| 1781: | * @static |
| 1782: | */ |
| 1783: | public static function hasResolvedGuards() |
| 1784: | { |
| 1785: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1786: | return $instance->hasResolvedGuards(); |
| 1787: | } |
| 1788: | /** |
| 1789: | * Forget all of the resolved guard instances. |
| 1790: | * |
| 1791: | * @return \Illuminate\Auth\AuthManager |
| 1792: | * @static |
| 1793: | */ |
| 1794: | public static function forgetGuards() |
| 1795: | { |
| 1796: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1797: | return $instance->forgetGuards(); |
| 1798: | } |
| 1799: | /** |
| 1800: | * Set the application instance used by the manager. |
| 1801: | * |
| 1802: | * @param \Illuminate\Contracts\Foundation\Application $app |
| 1803: | * @return \Illuminate\Auth\AuthManager |
| 1804: | * @static |
| 1805: | */ |
| 1806: | public static function setApplication($app) |
| 1807: | { |
| 1808: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1809: | return $instance->setApplication($app); |
| 1810: | } |
| 1811: | /** |
| 1812: | * Create the user provider implementation for the driver. |
| 1813: | * |
| 1814: | * @param string|null $provider |
| 1815: | * @return \Illuminate\Contracts\Auth\UserProvider|null |
| 1816: | * @throws \InvalidArgumentException |
| 1817: | * @static |
| 1818: | */ |
| 1819: | public static function createUserProvider($provider = null) |
| 1820: | { |
| 1821: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1822: | return $instance->createUserProvider($provider); |
| 1823: | } |
| 1824: | /** |
| 1825: | * Get the default user provider name. |
| 1826: | * |
| 1827: | * @return string |
| 1828: | * @static |
| 1829: | */ |
| 1830: | public static function getDefaultUserProvider() |
| 1831: | { |
| 1832: | /** @var \Illuminate\Auth\AuthManager $instance */ |
| 1833: | return $instance->getDefaultUserProvider(); |
| 1834: | } |
| 1835: | /** |
| 1836: | * Get the currently authenticated user. |
| 1837: | * |
| 1838: | * @return \App\Models\User|null |
| 1839: | * @static |
| 1840: | */ |
| 1841: | public static function user() |
| 1842: | { |
| 1843: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1844: | return $instance->user(); |
| 1845: | } |
| 1846: | /** |
| 1847: | * Get the ID for the currently authenticated user. |
| 1848: | * |
| 1849: | * @return int|string|null |
| 1850: | * @static |
| 1851: | */ |
| 1852: | public static function id() |
| 1853: | { |
| 1854: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1855: | return $instance->id(); |
| 1856: | } |
| 1857: | /** |
| 1858: | * Log a user into the application without sessions or cookies. |
| 1859: | * |
| 1860: | * @param array $credentials |
| 1861: | * @return bool |
| 1862: | * @static |
| 1863: | */ |
| 1864: | public static function once($credentials = []) |
| 1865: | { |
| 1866: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1867: | return $instance->once($credentials); |
| 1868: | } |
| 1869: | /** |
| 1870: | * Log the given user ID into the application without sessions or cookies. |
| 1871: | * |
| 1872: | * @param mixed $id |
| 1873: | * @return \App\Models\User|false |
| 1874: | * @static |
| 1875: | */ |
| 1876: | public static function onceUsingId($id) |
| 1877: | { |
| 1878: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1879: | return $instance->onceUsingId($id); |
| 1880: | } |
| 1881: | /** |
| 1882: | * Validate a user's credentials. |
| 1883: | * |
| 1884: | * @param array $credentials |
| 1885: | * @return bool |
| 1886: | * @static |
| 1887: | */ |
| 1888: | public static function validate($credentials = []) |
| 1889: | { |
| 1890: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1891: | return $instance->validate($credentials); |
| 1892: | } |
| 1893: | /** |
| 1894: | * Attempt to authenticate using HTTP Basic Auth. |
| 1895: | * |
| 1896: | * @param string $field |
| 1897: | * @param array $extraConditions |
| 1898: | * @return \Symfony\Component\HttpFoundation\Response|null |
| 1899: | * @throws \Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException |
| 1900: | * @static |
| 1901: | */ |
| 1902: | public static function basic($field = 'email', $extraConditions = []) |
| 1903: | { |
| 1904: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1905: | return $instance->basic($field, $extraConditions); |
| 1906: | } |
| 1907: | /** |
| 1908: | * Perform a stateless HTTP Basic login attempt. |
| 1909: | * |
| 1910: | * @param string $field |
| 1911: | * @param array $extraConditions |
| 1912: | * @return \Symfony\Component\HttpFoundation\Response|null |
| 1913: | * @throws \Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException |
| 1914: | * @static |
| 1915: | */ |
| 1916: | public static function onceBasic($field = 'email', $extraConditions = []) |
| 1917: | { |
| 1918: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1919: | return $instance->onceBasic($field, $extraConditions); |
| 1920: | } |
| 1921: | /** |
| 1922: | * Attempt to authenticate a user using the given credentials. |
| 1923: | * |
| 1924: | * @param array $credentials |
| 1925: | * @param bool $remember |
| 1926: | * @return bool |
| 1927: | * @static |
| 1928: | */ |
| 1929: | public static function attempt($credentials = [], $remember = false) |
| 1930: | { |
| 1931: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1932: | return $instance->attempt($credentials, $remember); |
| 1933: | } |
| 1934: | /** |
| 1935: | * Attempt to authenticate a user with credentials and additional callbacks. |
| 1936: | * |
| 1937: | * @param array $credentials |
| 1938: | * @param array|callable $callbacks |
| 1939: | * @param bool $remember |
| 1940: | * @return bool |
| 1941: | * @static |
| 1942: | */ |
| 1943: | public static function attemptWhen($credentials = [], $callbacks = null, $remember = false) |
| 1944: | { |
| 1945: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1946: | return $instance->attemptWhen($credentials, $callbacks, $remember); |
| 1947: | } |
| 1948: | /** |
| 1949: | * Log the given user ID into the application. |
| 1950: | * |
| 1951: | * @param mixed $id |
| 1952: | * @param bool $remember |
| 1953: | * @return \App\Models\User|false |
| 1954: | * @static |
| 1955: | */ |
| 1956: | public static function loginUsingId($id, $remember = false) |
| 1957: | { |
| 1958: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1959: | return $instance->loginUsingId($id, $remember); |
| 1960: | } |
| 1961: | /** |
| 1962: | * Log a user into the application. |
| 1963: | * |
| 1964: | * @param \Illuminate\Contracts\Auth\Authenticatable $user |
| 1965: | * @param bool $remember |
| 1966: | * @return void |
| 1967: | * @static |
| 1968: | */ |
| 1969: | public static function login($user, $remember = false) |
| 1970: | { |
| 1971: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1972: | $instance->login($user, $remember); |
| 1973: | } |
| 1974: | /** |
| 1975: | * Log the user out of the application. |
| 1976: | * |
| 1977: | * @return void |
| 1978: | * @static |
| 1979: | */ |
| 1980: | public static function logout() |
| 1981: | { |
| 1982: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1983: | $instance->logout(); |
| 1984: | } |
| 1985: | /** |
| 1986: | * Log the user out of the application on their current device only. |
| 1987: | * |
| 1988: | * This method does not cycle the "remember" token. |
| 1989: | * |
| 1990: | * @return void |
| 1991: | * @static |
| 1992: | */ |
| 1993: | public static function logoutCurrentDevice() |
| 1994: | { |
| 1995: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 1996: | $instance->logoutCurrentDevice(); |
| 1997: | } |
| 1998: | /** |
| 1999: | * Invalidate other sessions for the current user. |
| 2000: | * |
| 2001: | * The application must be using the AuthenticateSession middleware. |
| 2002: | * |
| 2003: | * @param string $password |
| 2004: | * @param string $attribute |
| 2005: | * @return \App\Models\User|null |
| 2006: | * @throws \Illuminate\Auth\AuthenticationException |
| 2007: | * @static |
| 2008: | */ |
| 2009: | public static function logoutOtherDevices($password, $attribute = 'password') |
| 2010: | { |
| 2011: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2012: | return $instance->logoutOtherDevices($password, $attribute); |
| 2013: | } |
| 2014: | /** |
| 2015: | * Register an authentication attempt event listener. |
| 2016: | * |
| 2017: | * @param mixed $callback |
| 2018: | * @return void |
| 2019: | * @static |
| 2020: | */ |
| 2021: | public static function attempting($callback) |
| 2022: | { |
| 2023: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2024: | $instance->attempting($callback); |
| 2025: | } |
| 2026: | /** |
| 2027: | * Get the last user we attempted to authenticate. |
| 2028: | * |
| 2029: | * @return \App\Models\User |
| 2030: | * @static |
| 2031: | */ |
| 2032: | public static function getLastAttempted() |
| 2033: | { |
| 2034: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2035: | return $instance->getLastAttempted(); |
| 2036: | } |
| 2037: | /** |
| 2038: | * Get a unique identifier for the auth session value. |
| 2039: | * |
| 2040: | * @return string |
| 2041: | * @static |
| 2042: | */ |
| 2043: | public static function getName() |
| 2044: | { |
| 2045: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2046: | return $instance->getName(); |
| 2047: | } |
| 2048: | /** |
| 2049: | * Get the name of the cookie used to store the "recaller". |
| 2050: | * |
| 2051: | * @return string |
| 2052: | * @static |
| 2053: | */ |
| 2054: | public static function getRecallerName() |
| 2055: | { |
| 2056: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2057: | return $instance->getRecallerName(); |
| 2058: | } |
| 2059: | /** |
| 2060: | * Determine if the user was authenticated via "remember me" cookie. |
| 2061: | * |
| 2062: | * @return bool |
| 2063: | * @static |
| 2064: | */ |
| 2065: | public static function viaRemember() |
| 2066: | { |
| 2067: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2068: | return $instance->viaRemember(); |
| 2069: | } |
| 2070: | /** |
| 2071: | * Set the number of minutes the remember me cookie should be valid for. |
| 2072: | * |
| 2073: | * @param int $minutes |
| 2074: | * @return \Illuminate\Auth\SessionGuard |
| 2075: | * @static |
| 2076: | */ |
| 2077: | public static function setRememberDuration($minutes) |
| 2078: | { |
| 2079: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2080: | return $instance->setRememberDuration($minutes); |
| 2081: | } |
| 2082: | /** |
| 2083: | * Get the cookie creator instance used by the guard. |
| 2084: | * |
| 2085: | * @return \Illuminate\Contracts\Cookie\QueueingFactory |
| 2086: | * @throws \RuntimeException |
| 2087: | * @static |
| 2088: | */ |
| 2089: | public static function getCookieJar() |
| 2090: | { |
| 2091: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2092: | return $instance->getCookieJar(); |
| 2093: | } |
| 2094: | /** |
| 2095: | * Set the cookie creator instance used by the guard. |
| 2096: | * |
| 2097: | * @param \Illuminate\Contracts\Cookie\QueueingFactory $cookie |
| 2098: | * @return void |
| 2099: | * @static |
| 2100: | */ |
| 2101: | public static function setCookieJar($cookie) |
| 2102: | { |
| 2103: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2104: | $instance->setCookieJar($cookie); |
| 2105: | } |
| 2106: | /** |
| 2107: | * Get the event dispatcher instance. |
| 2108: | * |
| 2109: | * @return \Illuminate\Contracts\Events\Dispatcher |
| 2110: | * @static |
| 2111: | */ |
| 2112: | public static function getDispatcher() |
| 2113: | { |
| 2114: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2115: | return $instance->getDispatcher(); |
| 2116: | } |
| 2117: | /** |
| 2118: | * Set the event dispatcher instance. |
| 2119: | * |
| 2120: | * @param \Illuminate\Contracts\Events\Dispatcher $events |
| 2121: | * @return void |
| 2122: | * @static |
| 2123: | */ |
| 2124: | public static function setDispatcher($events) |
| 2125: | { |
| 2126: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2127: | $instance->setDispatcher($events); |
| 2128: | } |
| 2129: | /** |
| 2130: | * Get the session store used by the guard. |
| 2131: | * |
| 2132: | * @return \Illuminate\Contracts\Session\Session |
| 2133: | * @static |
| 2134: | */ |
| 2135: | public static function getSession() |
| 2136: | { |
| 2137: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2138: | return $instance->getSession(); |
| 2139: | } |
| 2140: | /** |
| 2141: | * Return the currently cached user. |
| 2142: | * |
| 2143: | * @return \App\Models\User|null |
| 2144: | * @static |
| 2145: | */ |
| 2146: | public static function getUser() |
| 2147: | { |
| 2148: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2149: | return $instance->getUser(); |
| 2150: | } |
| 2151: | /** |
| 2152: | * Set the current user. |
| 2153: | * |
| 2154: | * @param \Illuminate\Contracts\Auth\Authenticatable $user |
| 2155: | * @return \Illuminate\Auth\SessionGuard |
| 2156: | * @static |
| 2157: | */ |
| 2158: | public static function setUser($user) |
| 2159: | { |
| 2160: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2161: | return $instance->setUser($user); |
| 2162: | } |
| 2163: | /** |
| 2164: | * Get the current request instance. |
| 2165: | * |
| 2166: | * @return \Symfony\Component\HttpFoundation\Request |
| 2167: | * @static |
| 2168: | */ |
| 2169: | public static function getRequest() |
| 2170: | { |
| 2171: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2172: | return $instance->getRequest(); |
| 2173: | } |
| 2174: | /** |
| 2175: | * Set the current request instance. |
| 2176: | * |
| 2177: | * @param \Symfony\Component\HttpFoundation\Request $request |
| 2178: | * @return \Illuminate\Auth\SessionGuard |
| 2179: | * @static |
| 2180: | */ |
| 2181: | public static function setRequest($request) |
| 2182: | { |
| 2183: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2184: | return $instance->setRequest($request); |
| 2185: | } |
| 2186: | /** |
| 2187: | * Determine if the current user is authenticated. If not, throw an exception. |
| 2188: | * |
| 2189: | * @return \App\Models\User |
| 2190: | * @throws \Illuminate\Auth\AuthenticationException |
| 2191: | * @static |
| 2192: | */ |
| 2193: | public static function authenticate() |
| 2194: | { |
| 2195: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2196: | return $instance->authenticate(); |
| 2197: | } |
| 2198: | /** |
| 2199: | * Determine if the guard has a user instance. |
| 2200: | * |
| 2201: | * @return bool |
| 2202: | * @static |
| 2203: | */ |
| 2204: | public static function hasUser() |
| 2205: | { |
| 2206: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2207: | return $instance->hasUser(); |
| 2208: | } |
| 2209: | /** |
| 2210: | * Determine if the current user is authenticated. |
| 2211: | * |
| 2212: | * @return bool |
| 2213: | * @static |
| 2214: | */ |
| 2215: | public static function check() |
| 2216: | { |
| 2217: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2218: | return $instance->check(); |
| 2219: | } |
| 2220: | /** |
| 2221: | * Determine if the current user is a guest. |
| 2222: | * |
| 2223: | * @return bool |
| 2224: | * @static |
| 2225: | */ |
| 2226: | public static function guest() |
| 2227: | { |
| 2228: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2229: | return $instance->guest(); |
| 2230: | } |
| 2231: | /** |
| 2232: | * Get the user provider used by the guard. |
| 2233: | * |
| 2234: | * @return \Illuminate\Contracts\Auth\UserProvider |
| 2235: | * @static |
| 2236: | */ |
| 2237: | public static function getProvider() |
| 2238: | { |
| 2239: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2240: | return $instance->getProvider(); |
| 2241: | } |
| 2242: | /** |
| 2243: | * Set the user provider used by the guard. |
| 2244: | * |
| 2245: | * @param \Illuminate\Contracts\Auth\UserProvider $provider |
| 2246: | * @return void |
| 2247: | * @static |
| 2248: | */ |
| 2249: | public static function setProvider($provider) |
| 2250: | { |
| 2251: | /** @var \Illuminate\Auth\SessionGuard $instance */ |
| 2252: | $instance->setProvider($provider); |
| 2253: | } |
| 2254: | /** |
| 2255: | * Register a custom macro. |
| 2256: | * |
| 2257: | * @param string $name |
| 2258: | * @param object|callable $macro |
| 2259: | * @return void |
| 2260: | * @static |
| 2261: | */ |
| 2262: | public static function macro($name, $macro) |
| 2263: | { |
| 2264: | \Illuminate\Auth\SessionGuard::macro($name, $macro); |
| 2265: | } |
| 2266: | /** |
| 2267: | * Mix another object into the class. |
| 2268: | * |
| 2269: | * @param object $mixin |
| 2270: | * @param bool $replace |
| 2271: | * @return void |
| 2272: | * @throws \ReflectionException |
| 2273: | * @static |
| 2274: | */ |
| 2275: | public static function mixin($mixin, $replace = true) |
| 2276: | { |
| 2277: | \Illuminate\Auth\SessionGuard::mixin($mixin, $replace); |
| 2278: | } |
| 2279: | /** |
| 2280: | * Checks if macro is registered. |
| 2281: | * |
| 2282: | * @param string $name |
| 2283: | * @return bool |
| 2284: | * @static |
| 2285: | */ |
| 2286: | public static function hasMacro($name) |
| 2287: | { |
| 2288: | return \Illuminate\Auth\SessionGuard::hasMacro($name); |
| 2289: | } |
| 2290: | /** |
| 2291: | * Flush the existing macros. |
| 2292: | * |
| 2293: | * @return void |
| 2294: | * @static |
| 2295: | */ |
| 2296: | public static function flushMacros() |
| 2297: | { |
| 2298: | \Illuminate\Auth\SessionGuard::flushMacros(); |
| 2299: | } |
| 2300: | |
| 2301: | } |
| 2302: | /** |
| 2303: | * |
| 2304: | * |
| 2305: | * @see \Illuminate\View\Compilers\BladeCompiler |
| 2306: | */ |
| 2307: | class Blade { |
| 2308: | /** |
| 2309: | * Compile the view at the given path. |
| 2310: | * |
| 2311: | * @param string|null $path |
| 2312: | * @return void |
| 2313: | * @static |
| 2314: | */ |
| 2315: | public static function compile($path = null) |
| 2316: | { |
| 2317: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2318: | $instance->compile($path); |
| 2319: | } |
| 2320: | /** |
| 2321: | * Get the path currently being compiled. |
| 2322: | * |
| 2323: | * @return string |
| 2324: | * @static |
| 2325: | */ |
| 2326: | public static function getPath() |
| 2327: | { |
| 2328: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2329: | return $instance->getPath(); |
| 2330: | } |
| 2331: | /** |
| 2332: | * Set the path currently being compiled. |
| 2333: | * |
| 2334: | * @param string $path |
| 2335: | * @return void |
| 2336: | * @static |
| 2337: | */ |
| 2338: | public static function setPath($path) |
| 2339: | { |
| 2340: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2341: | $instance->setPath($path); |
| 2342: | } |
| 2343: | /** |
| 2344: | * Compile the given Blade template contents. |
| 2345: | * |
| 2346: | * @param string $value |
| 2347: | * @return string |
| 2348: | * @static |
| 2349: | */ |
| 2350: | public static function compileString($value) |
| 2351: | { |
| 2352: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2353: | return $instance->compileString($value); |
| 2354: | } |
| 2355: | /** |
| 2356: | * Evaluate and render a Blade string to HTML. |
| 2357: | * |
| 2358: | * @param string $string |
| 2359: | * @param array $data |
| 2360: | * @param bool $deleteCachedView |
| 2361: | * @return string |
| 2362: | * @static |
| 2363: | */ |
| 2364: | public static function render($string, $data = [], $deleteCachedView = false) |
| 2365: | { |
| 2366: | return \Illuminate\View\Compilers\BladeCompiler::render($string, $data, $deleteCachedView); |
| 2367: | } |
| 2368: | /** |
| 2369: | * Render a component instance to HTML. |
| 2370: | * |
| 2371: | * @param \Illuminate\View\Component $component |
| 2372: | * @return string |
| 2373: | * @static |
| 2374: | */ |
| 2375: | public static function renderComponent($component) |
| 2376: | { |
| 2377: | return \Illuminate\View\Compilers\BladeCompiler::renderComponent($component); |
| 2378: | } |
| 2379: | /** |
| 2380: | * Strip the parentheses from the given expression. |
| 2381: | * |
| 2382: | * @param string $expression |
| 2383: | * @return string |
| 2384: | * @static |
| 2385: | */ |
| 2386: | public static function stripParentheses($expression) |
| 2387: | { |
| 2388: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2389: | return $instance->stripParentheses($expression); |
| 2390: | } |
| 2391: | /** |
| 2392: | * Register a custom Blade compiler. |
| 2393: | * |
| 2394: | * @param callable $compiler |
| 2395: | * @return void |
| 2396: | * @static |
| 2397: | */ |
| 2398: | public static function extend($compiler) |
| 2399: | { |
| 2400: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2401: | $instance->extend($compiler); |
| 2402: | } |
| 2403: | /** |
| 2404: | * Get the extensions used by the compiler. |
| 2405: | * |
| 2406: | * @return array |
| 2407: | * @static |
| 2408: | */ |
| 2409: | public static function getExtensions() |
| 2410: | { |
| 2411: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2412: | return $instance->getExtensions(); |
| 2413: | } |
| 2414: | /** |
| 2415: | * Register an "if" statement directive. |
| 2416: | * |
| 2417: | * @param string $name |
| 2418: | * @param callable $callback |
| 2419: | * @return void |
| 2420: | * @static |
| 2421: | */ |
| 2422: | public static function if($name, $callback) |
| 2423: | { |
| 2424: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2425: | $instance->if($name, $callback); |
| 2426: | } |
| 2427: | /** |
| 2428: | * Check the result of a condition. |
| 2429: | * |
| 2430: | * @param string $name |
| 2431: | * @param array $parameters |
| 2432: | * @return bool |
| 2433: | * @static |
| 2434: | */ |
| 2435: | public static function check($name, ...$parameters) |
| 2436: | { |
| 2437: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2438: | return $instance->check($name, ...$parameters); |
| 2439: | } |
| 2440: | /** |
| 2441: | * Register a class-based component alias directive. |
| 2442: | * |
| 2443: | * @param string $class |
| 2444: | * @param string|null $alias |
| 2445: | * @param string $prefix |
| 2446: | * @return void |
| 2447: | * @static |
| 2448: | */ |
| 2449: | public static function component($class, $alias = null, $prefix = '') |
| 2450: | { |
| 2451: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2452: | $instance->component($class, $alias, $prefix); |
| 2453: | } |
| 2454: | /** |
| 2455: | * Register an array of class-based components. |
| 2456: | * |
| 2457: | * @param array $components |
| 2458: | * @param string $prefix |
| 2459: | * @return void |
| 2460: | * @static |
| 2461: | */ |
| 2462: | public static function components($components, $prefix = '') |
| 2463: | { |
| 2464: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2465: | $instance->components($components, $prefix); |
| 2466: | } |
| 2467: | /** |
| 2468: | * Get the registered class component aliases. |
| 2469: | * |
| 2470: | * @return array |
| 2471: | * @static |
| 2472: | */ |
| 2473: | public static function getClassComponentAliases() |
| 2474: | { |
| 2475: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2476: | return $instance->getClassComponentAliases(); |
| 2477: | } |
| 2478: | /** |
| 2479: | * Register an anonymous component namespace. |
| 2480: | * |
| 2481: | * @param string $directory |
| 2482: | * @param string|null $prefix |
| 2483: | * @return void |
| 2484: | * @static |
| 2485: | */ |
| 2486: | public static function anonymousComponentNamespace($directory, $prefix = null) |
| 2487: | { |
| 2488: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2489: | $instance->anonymousComponentNamespace($directory, $prefix); |
| 2490: | } |
| 2491: | /** |
| 2492: | * Register a class-based component namespace. |
| 2493: | * |
| 2494: | * @param string $namespace |
| 2495: | * @param string $prefix |
| 2496: | * @return void |
| 2497: | * @static |
| 2498: | */ |
| 2499: | public static function componentNamespace($namespace, $prefix) |
| 2500: | { |
| 2501: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2502: | $instance->componentNamespace($namespace, $prefix); |
| 2503: | } |
| 2504: | /** |
| 2505: | * Get the registered anonymous component namespaces. |
| 2506: | * |
| 2507: | * @return array |
| 2508: | * @static |
| 2509: | */ |
| 2510: | public static function getAnonymousComponentNamespaces() |
| 2511: | { |
| 2512: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2513: | return $instance->getAnonymousComponentNamespaces(); |
| 2514: | } |
| 2515: | /** |
| 2516: | * Get the registered class component namespaces. |
| 2517: | * |
| 2518: | * @return array |
| 2519: | * @static |
| 2520: | */ |
| 2521: | public static function getClassComponentNamespaces() |
| 2522: | { |
| 2523: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2524: | return $instance->getClassComponentNamespaces(); |
| 2525: | } |
| 2526: | /** |
| 2527: | * Register a component alias directive. |
| 2528: | * |
| 2529: | * @param string $path |
| 2530: | * @param string|null $alias |
| 2531: | * @return void |
| 2532: | * @static |
| 2533: | */ |
| 2534: | public static function aliasComponent($path, $alias = null) |
| 2535: | { |
| 2536: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2537: | $instance->aliasComponent($path, $alias); |
| 2538: | } |
| 2539: | /** |
| 2540: | * Register an include alias directive. |
| 2541: | * |
| 2542: | * @param string $path |
| 2543: | * @param string|null $alias |
| 2544: | * @return void |
| 2545: | * @static |
| 2546: | */ |
| 2547: | public static function include($path, $alias = null) |
| 2548: | { |
| 2549: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2550: | $instance->include($path, $alias); |
| 2551: | } |
| 2552: | /** |
| 2553: | * Register an include alias directive. |
| 2554: | * |
| 2555: | * @param string $path |
| 2556: | * @param string|null $alias |
| 2557: | * @return void |
| 2558: | * @static |
| 2559: | */ |
| 2560: | public static function aliasInclude($path, $alias = null) |
| 2561: | { |
| 2562: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2563: | $instance->aliasInclude($path, $alias); |
| 2564: | } |
| 2565: | /** |
| 2566: | * Register a handler for custom directives. |
| 2567: | * |
| 2568: | * @param string $name |
| 2569: | * @param callable $handler |
| 2570: | * @return void |
| 2571: | * @throws \InvalidArgumentException |
| 2572: | * @static |
| 2573: | */ |
| 2574: | public static function directive($name, $handler) |
| 2575: | { |
| 2576: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2577: | $instance->directive($name, $handler); |
| 2578: | } |
| 2579: | /** |
| 2580: | * Get the list of custom directives. |
| 2581: | * |
| 2582: | * @return array |
| 2583: | * @static |
| 2584: | */ |
| 2585: | public static function getCustomDirectives() |
| 2586: | { |
| 2587: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2588: | return $instance->getCustomDirectives(); |
| 2589: | } |
| 2590: | /** |
| 2591: | * Register a new precompiler. |
| 2592: | * |
| 2593: | * @param callable $precompiler |
| 2594: | * @return void |
| 2595: | * @static |
| 2596: | */ |
| 2597: | public static function precompiler($precompiler) |
| 2598: | { |
| 2599: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2600: | $instance->precompiler($precompiler); |
| 2601: | } |
| 2602: | /** |
| 2603: | * Set the echo format to be used by the compiler. |
| 2604: | * |
| 2605: | * @param string $format |
| 2606: | * @return void |
| 2607: | * @static |
| 2608: | */ |
| 2609: | public static function setEchoFormat($format) |
| 2610: | { |
| 2611: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2612: | $instance->setEchoFormat($format); |
| 2613: | } |
| 2614: | /** |
| 2615: | * Set the "echo" format to double encode entities. |
| 2616: | * |
| 2617: | * @return void |
| 2618: | * @static |
| 2619: | */ |
| 2620: | public static function withDoubleEncoding() |
| 2621: | { |
| 2622: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2623: | $instance->withDoubleEncoding(); |
| 2624: | } |
| 2625: | /** |
| 2626: | * Set the "echo" format to not double encode entities. |
| 2627: | * |
| 2628: | * @return void |
| 2629: | * @static |
| 2630: | */ |
| 2631: | public static function withoutDoubleEncoding() |
| 2632: | { |
| 2633: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2634: | $instance->withoutDoubleEncoding(); |
| 2635: | } |
| 2636: | /** |
| 2637: | * Indicate that component tags should not be compiled. |
| 2638: | * |
| 2639: | * @return void |
| 2640: | * @static |
| 2641: | */ |
| 2642: | public static function withoutComponentTags() |
| 2643: | { |
| 2644: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2645: | $instance->withoutComponentTags(); |
| 2646: | } |
| 2647: | /** |
| 2648: | * Get the path to the compiled version of a view. |
| 2649: | * |
| 2650: | * @param string $path |
| 2651: | * @return string |
| 2652: | * @static |
| 2653: | */ |
| 2654: | public static function getCompiledPath($path) |
| 2655: | { //Method inherited from \Illuminate\View\Compilers\Compiler |
| 2656: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2657: | return $instance->getCompiledPath($path); |
| 2658: | } |
| 2659: | /** |
| 2660: | * Determine if the view at the given path is expired. |
| 2661: | * |
| 2662: | * @param string $path |
| 2663: | * @return bool |
| 2664: | * @static |
| 2665: | */ |
| 2666: | public static function isExpired($path) |
| 2667: | { //Method inherited from \Illuminate\View\Compilers\Compiler |
| 2668: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2669: | return $instance->isExpired($path); |
| 2670: | } |
| 2671: | /** |
| 2672: | * Get a new component hash for a component name. |
| 2673: | * |
| 2674: | * @param string $component |
| 2675: | * @return string |
| 2676: | * @static |
| 2677: | */ |
| 2678: | public static function newComponentHash($component) |
| 2679: | { |
| 2680: | return \Illuminate\View\Compilers\BladeCompiler::newComponentHash($component); |
| 2681: | } |
| 2682: | /** |
| 2683: | * Compile a class component opening. |
| 2684: | * |
| 2685: | * @param string $component |
| 2686: | * @param string $alias |
| 2687: | * @param string $data |
| 2688: | * @param string $hash |
| 2689: | * @return string |
| 2690: | * @static |
| 2691: | */ |
| 2692: | public static function compileClassComponentOpening($component, $alias, $data, $hash) |
| 2693: | { |
| 2694: | return \Illuminate\View\Compilers\BladeCompiler::compileClassComponentOpening($component, $alias, $data, $hash); |
| 2695: | } |
| 2696: | /** |
| 2697: | * Compile the end-component statements into valid PHP. |
| 2698: | * |
| 2699: | * @return string |
| 2700: | * @static |
| 2701: | */ |
| 2702: | public static function compileEndComponentClass() |
| 2703: | { |
| 2704: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2705: | return $instance->compileEndComponentClass(); |
| 2706: | } |
| 2707: | /** |
| 2708: | * Sanitize the given component attribute value. |
| 2709: | * |
| 2710: | * @param mixed $value |
| 2711: | * @return mixed |
| 2712: | * @static |
| 2713: | */ |
| 2714: | public static function sanitizeComponentAttribute($value) |
| 2715: | { |
| 2716: | return \Illuminate\View\Compilers\BladeCompiler::sanitizeComponentAttribute($value); |
| 2717: | } |
| 2718: | /** |
| 2719: | * Compile an end-once block into valid PHP. |
| 2720: | * |
| 2721: | * @return string |
| 2722: | * @static |
| 2723: | */ |
| 2724: | public static function compileEndOnce() |
| 2725: | { |
| 2726: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2727: | return $instance->compileEndOnce(); |
| 2728: | } |
| 2729: | /** |
| 2730: | * Add a handler to be executed before echoing a given class. |
| 2731: | * |
| 2732: | * @param string|callable $class |
| 2733: | * @param callable|null $handler |
| 2734: | * @return void |
| 2735: | * @static |
| 2736: | */ |
| 2737: | public static function stringable($class, $handler = null) |
| 2738: | { |
| 2739: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2740: | $instance->stringable($class, $handler); |
| 2741: | } |
| 2742: | /** |
| 2743: | * Compile Blade echos into valid PHP. |
| 2744: | * |
| 2745: | * @param string $value |
| 2746: | * @return string |
| 2747: | * @static |
| 2748: | */ |
| 2749: | public static function compileEchos($value) |
| 2750: | { |
| 2751: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2752: | return $instance->compileEchos($value); |
| 2753: | } |
| 2754: | /** |
| 2755: | * Apply the echo handler for the value if it exists. |
| 2756: | * |
| 2757: | * @param string $value |
| 2758: | * @return string |
| 2759: | * @static |
| 2760: | */ |
| 2761: | public static function applyEchoHandler($value) |
| 2762: | { |
| 2763: | /** @var \Illuminate\View\Compilers\BladeCompiler $instance */ |
| 2764: | return $instance->applyEchoHandler($value); |
| 2765: | } |
| 2766: | |
| 2767: | } |
| 2768: | /** |
| 2769: | * |
| 2770: | * |
| 2771: | * @method static \Illuminate\Broadcasting\Broadcasters\Broadcaster channel(string $channel, callable|string $callback, array $options = []) |
| 2772: | * @method static mixed auth(\Illuminate\Http\Request $request) |
| 2773: | * @method static void resolveAuthenticatedUserUsing(Closure $callback) |
| 2774: | * @see \Illuminate\Contracts\Broadcasting\Factory |
| 2775: | */ |
| 2776: | class Broadcast { |
| 2777: | /** |
| 2778: | * Register the routes for handling broadcast channel authentication and sockets. |
| 2779: | * |
| 2780: | * @param array|null $attributes |
| 2781: | * @return void |
| 2782: | * @static |
| 2783: | */ |
| 2784: | public static function routes($attributes = null) |
| 2785: | { |
| 2786: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2787: | $instance->routes($attributes); |
| 2788: | } |
| 2789: | /** |
| 2790: | * Register the routes for handling broadcast user authentication. |
| 2791: | * |
| 2792: | * @param array|null $attributes |
| 2793: | * @return void |
| 2794: | * @static |
| 2795: | */ |
| 2796: | public static function userRoutes($attributes = null) |
| 2797: | { |
| 2798: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2799: | $instance->userRoutes($attributes); |
| 2800: | } |
| 2801: | /** |
| 2802: | * Register the routes for handling broadcast authentication and sockets. |
| 2803: | * |
| 2804: | * Alias of "routes" method. |
| 2805: | * |
| 2806: | * @param array|null $attributes |
| 2807: | * @return void |
| 2808: | * @static |
| 2809: | */ |
| 2810: | public static function channelRoutes($attributes = null) |
| 2811: | { |
| 2812: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2813: | $instance->channelRoutes($attributes); |
| 2814: | } |
| 2815: | /** |
| 2816: | * Get the socket ID for the given request. |
| 2817: | * |
| 2818: | * @param \Illuminate\Http\Request|null $request |
| 2819: | * @return string|null |
| 2820: | * @static |
| 2821: | */ |
| 2822: | public static function socket($request = null) |
| 2823: | { |
| 2824: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2825: | return $instance->socket($request); |
| 2826: | } |
| 2827: | /** |
| 2828: | * Begin broadcasting an event. |
| 2829: | * |
| 2830: | * @param mixed|null $event |
| 2831: | * @return \Illuminate\Broadcasting\PendingBroadcast |
| 2832: | * @static |
| 2833: | */ |
| 2834: | public static function event($event = null) |
| 2835: | { |
| 2836: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2837: | return $instance->event($event); |
| 2838: | } |
| 2839: | /** |
| 2840: | * Queue the given event for broadcast. |
| 2841: | * |
| 2842: | * @param mixed $event |
| 2843: | * @return void |
| 2844: | * @static |
| 2845: | */ |
| 2846: | public static function queue($event) |
| 2847: | { |
| 2848: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2849: | $instance->queue($event); |
| 2850: | } |
| 2851: | /** |
| 2852: | * Get a driver instance. |
| 2853: | * |
| 2854: | * @param string|null $driver |
| 2855: | * @return mixed |
| 2856: | * @static |
| 2857: | */ |
| 2858: | public static function connection($driver = null) |
| 2859: | { |
| 2860: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2861: | return $instance->connection($driver); |
| 2862: | } |
| 2863: | /** |
| 2864: | * Get a driver instance. |
| 2865: | * |
| 2866: | * @param string|null $name |
| 2867: | * @return mixed |
| 2868: | * @static |
| 2869: | */ |
| 2870: | public static function driver($name = null) |
| 2871: | { |
| 2872: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2873: | return $instance->driver($name); |
| 2874: | } |
| 2875: | /** |
| 2876: | * Get a Pusher instance for the given configuration. |
| 2877: | * |
| 2878: | * @param array $config |
| 2879: | * @return \Pusher\Pusher |
| 2880: | * @static |
| 2881: | */ |
| 2882: | public static function pusher($config) |
| 2883: | { |
| 2884: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2885: | return $instance->pusher($config); |
| 2886: | } |
| 2887: | /** |
| 2888: | * Get an Ably instance for the given configuration. |
| 2889: | * |
| 2890: | * @param array $config |
| 2891: | * @return \Ably\AblyRest |
| 2892: | * @static |
| 2893: | */ |
| 2894: | public static function ably($config) |
| 2895: | { |
| 2896: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2897: | return $instance->ably($config); |
| 2898: | } |
| 2899: | /** |
| 2900: | * Get the default driver name. |
| 2901: | * |
| 2902: | * @return string |
| 2903: | * @static |
| 2904: | */ |
| 2905: | public static function getDefaultDriver() |
| 2906: | { |
| 2907: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2908: | return $instance->getDefaultDriver(); |
| 2909: | } |
| 2910: | /** |
| 2911: | * Set the default driver name. |
| 2912: | * |
| 2913: | * @param string $name |
| 2914: | * @return void |
| 2915: | * @static |
| 2916: | */ |
| 2917: | public static function setDefaultDriver($name) |
| 2918: | { |
| 2919: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2920: | $instance->setDefaultDriver($name); |
| 2921: | } |
| 2922: | /** |
| 2923: | * Disconnect the given disk and remove from local cache. |
| 2924: | * |
| 2925: | * @param string|null $name |
| 2926: | * @return void |
| 2927: | * @static |
| 2928: | */ |
| 2929: | public static function purge($name = null) |
| 2930: | { |
| 2931: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2932: | $instance->purge($name); |
| 2933: | } |
| 2934: | /** |
| 2935: | * Register a custom driver creator Closure. |
| 2936: | * |
| 2937: | * @param string $driver |
| 2938: | * @param \Closure $callback |
| 2939: | * @return \Illuminate\Broadcasting\BroadcastManager |
| 2940: | * @static |
| 2941: | */ |
| 2942: | public static function extend($driver, $callback) |
| 2943: | { |
| 2944: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2945: | return $instance->extend($driver, $callback); |
| 2946: | } |
| 2947: | /** |
| 2948: | * Get the application instance used by the manager. |
| 2949: | * |
| 2950: | * @return \Illuminate\Contracts\Foundation\Application |
| 2951: | * @static |
| 2952: | */ |
| 2953: | public static function getApplication() |
| 2954: | { |
| 2955: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2956: | return $instance->getApplication(); |
| 2957: | } |
| 2958: | /** |
| 2959: | * Set the application instance used by the manager. |
| 2960: | * |
| 2961: | * @param \Illuminate\Contracts\Foundation\Application $app |
| 2962: | * @return \Illuminate\Broadcasting\BroadcastManager |
| 2963: | * @static |
| 2964: | */ |
| 2965: | public static function setApplication($app) |
| 2966: | { |
| 2967: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2968: | return $instance->setApplication($app); |
| 2969: | } |
| 2970: | /** |
| 2971: | * Forget all of the resolved driver instances. |
| 2972: | * |
| 2973: | * @return \Illuminate\Broadcasting\BroadcastManager |
| 2974: | * @static |
| 2975: | */ |
| 2976: | public static function forgetDrivers() |
| 2977: | { |
| 2978: | /** @var \Illuminate\Broadcasting\BroadcastManager $instance */ |
| 2979: | return $instance->forgetDrivers(); |
| 2980: | } |
| 2981: | |
| 2982: | } |
| 2983: | /** |
| 2984: | * |
| 2985: | * |
| 2986: | * @see \Illuminate\Contracts\Bus\Dispatcher |
| 2987: | */ |
| 2988: | class Bus { |
| 2989: | /** |
| 2990: | * Dispatch a command to its appropriate handler. |
| 2991: | * |
| 2992: | * @param mixed $command |
| 2993: | * @return mixed |
| 2994: | * @static |
| 2995: | */ |
| 2996: | public static function dispatch($command) |
| 2997: | { |
| 2998: | /** @var \Illuminate\Bus\Dispatcher $instance */ |
| 2999: | return $instance->dispatch($command); |
| 3000: | } |
| 3001: | /** |
| 3002: | * Dispatch a command to its appropriate handler in the current process. |
| 3003: | * |
| 3004: | * Queueable jobs will be dispatched to the "sync" queue. |
| 3005: | * |
| 3006: | * @param mixed $command |
| 3007: | * @param mixed $handler |
| 3008: | * @return mixed |
| 3009: | * @static |
| 3010: | */ |
| 3011: | public static function dispatchSync($command, $handler = null) |
| 3012: | { |
| 3013: | /** @var \Illuminate\Bus\Dispatcher $instance */ |
| 3014: | return $instance->dispatchSync($command, $handler); |
| 3015: | } |
| 3016: | /** |
| 3017: | * Dispatch a command to its appropriate handler in the current process without using the synchronous queue. |
| 3018: | * |
| 3019: | * @param mixed $command |
| 3020: | * @param mixed $handler |
| 3021: | * @return mixed |
| 3022: | * @static |
| 3023: | */ |
| 3024: | public static function dispatchNow($command, $handler = null) |
| 3025: | { |
| 3026: | /** @var \Illuminate\Bus\Dispatcher $instance */ |
| 3027: | return $instance->dispatchNow($command, $handler); |
| 3028: | } |
| 3029: | /** |
| 3030: | * Attempt to find the batch with the given ID. |
| 3031: | * |
| 3032: | * @param string $batchId |
| 3033: | * @return \Illuminate\Bus\Batch|null |
| 3034: | * @static |
| 3035: | */ |
| 3036: | public static function findBatch($batchId) |
| 3037: | { |
| 3038: | /** @var \Illuminate\Bus\Dispatcher $instance */ |
| 3039: | return $instance->findBatch($batchId); |
| 3040: | } |
| 3041: | /** |
| 3042: | * Create a new batch of queueable jobs. |
| 3043: | * |
| 3044: | * @param \Illuminate\Support\Collection|array|mixed $jobs |
| 3045: | * @return \Illuminate\Bus\PendingBatch |
| 3046: | * @static |
| 3047: | */ |
| 3048: | public static function batch($jobs) |
| 3049: | { |
| 3050: | /** @var \Illuminate\Bus\Dispatcher $instance */ |
| 3051: | return $instance->batch($jobs); |
| 3052: | } |
| 3053: | /** |
| 3054: | * Create a new chain of queueable jobs. |
| 3055: | * |
| 3056: | * @param \Illuminate\Support\Collection|array $jobs |
| 3057: | * @return \Illuminate\Foundation\Bus\PendingChain |
| 3058: | * @static |
| 3059: | */ |
| 3060: | public static function chain($jobs) |
| 3061: | { |
| 3062: | /** @var \Illuminate\Bus\Dispatcher $instance */ |
| 3063: | return $instance->chain($jobs); |
| 3064: | } |
| 3065: | /** |
| 3066: | * Determine if the given command has a handler. |
| 3067: | * |
| 3068: | * @param mixed $command |
| 3069: | * @return bool |
| 3070: | * @static |
| 3071: | */ |
| 3072: | public static function hasCommandHandler($command) |
| 3073: | { |
| 3074: | /** @var \Illuminate\Bus\Dispatcher $instance */ |
| 3075: | return $instance->hasCommandHandler($command); |
| 3076: | } |
| 3077: | /** |
| 3078: | * Retrieve the handler for a command. |
| 3079: | * |
| 3080: | * @param mixed $command |
| 3081: | * @return bool|mixed |
| 3082: | * @static |
| 3083: | */ |
| 3084: | public static function getCommandHandler($command) |
| 3085: | { |
| 3086: | /** @var \Illuminate\Bus\Dispatcher $instance */ |
| 3087: | return $instance->getCommandHandler($command); |
| 3088: | } |
| 3089: | /** |
| 3090: | * Dispatch a command to its appropriate handler behind a queue. |
| 3091: | * |
| 3092: | * @param mixed $command |
| 3093: | * @return mixed |
| 3094: | * @throws \RuntimeException |
| 3095: | * @static |
| 3096: | */ |
| 3097: | public static function dispatchToQueue($command) |
| 3098: | { |
| 3099: | /** @var \Illuminate\Bus\Dispatcher $instance */ |
| 3100: | return $instance->dispatchToQueue($command); |
| 3101: | } |
| 3102: | /** |
| 3103: | * Dispatch a command to its appropriate handler after the current process. |
| 3104: | * |
| 3105: | * @param mixed $command |
| 3106: | * @param mixed $handler |
| 3107: | * @return void |
| 3108: | * @static |
| 3109: | */ |
| 3110: | public static function dispatchAfterResponse($command, $handler = null) |
| 3111: | { |
| 3112: | /** @var \Illuminate\Bus\Dispatcher $instance */ |
| 3113: | $instance->dispatchAfterResponse($command, $handler); |
| 3114: | } |
| 3115: | /** |
| 3116: | * Set the pipes through which commands should be piped before dispatching. |
| 3117: | * |
| 3118: | * @param array $pipes |
| 3119: | * @return \Illuminate\Bus\Dispatcher |
| 3120: | * @static |
| 3121: | */ |
| 3122: | public static function pipeThrough($pipes) |
| 3123: | { |
| 3124: | /** @var \Illuminate\Bus\Dispatcher $instance */ |
| 3125: | return $instance->pipeThrough($pipes); |
| 3126: | } |
| 3127: | /** |
| 3128: | * Map a command to a handler. |
| 3129: | * |
| 3130: | * @param array $map |
| 3131: | * @return \Illuminate\Bus\Dispatcher |
| 3132: | * @static |
| 3133: | */ |
| 3134: | public static function map($map) |
| 3135: | { |
| 3136: | /** @var \Illuminate\Bus\Dispatcher $instance */ |
| 3137: | return $instance->map($map); |
| 3138: | } |
| 3139: | /** |
| 3140: | * Assert if a job was dispatched based on a truth-test callback. |
| 3141: | * |
| 3142: | * @param string|\Closure $command |
| 3143: | * @param callable|int|null $callback |
| 3144: | * @return void |
| 3145: | * @static |
| 3146: | */ |
| 3147: | public static function assertDispatched($command, $callback = null) |
| 3148: | { |
| 3149: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3150: | $instance->assertDispatched($command, $callback); |
| 3151: | } |
| 3152: | /** |
| 3153: | * Assert if a job was pushed a number of times. |
| 3154: | * |
| 3155: | * @param string $command |
| 3156: | * @param int $times |
| 3157: | * @return void |
| 3158: | * @static |
| 3159: | */ |
| 3160: | public static function assertDispatchedTimes($command, $times = 1) |
| 3161: | { |
| 3162: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3163: | $instance->assertDispatchedTimes($command, $times); |
| 3164: | } |
| 3165: | /** |
| 3166: | * Determine if a job was dispatched based on a truth-test callback. |
| 3167: | * |
| 3168: | * @param string|\Closure $command |
| 3169: | * @param callable|null $callback |
| 3170: | * @return void |
| 3171: | * @static |
| 3172: | */ |
| 3173: | public static function assertNotDispatched($command, $callback = null) |
| 3174: | { |
| 3175: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3176: | $instance->assertNotDispatched($command, $callback); |
| 3177: | } |
| 3178: | /** |
| 3179: | * Assert that no jobs were dispatched. |
| 3180: | * |
| 3181: | * @return void |
| 3182: | * @static |
| 3183: | */ |
| 3184: | public static function assertNothingDispatched() |
| 3185: | { |
| 3186: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3187: | $instance->assertNothingDispatched(); |
| 3188: | } |
| 3189: | /** |
| 3190: | * Assert if a job was explicitly dispatched synchronously based on a truth-test callback. |
| 3191: | * |
| 3192: | * @param string|\Closure $command |
| 3193: | * @param callable|int|null $callback |
| 3194: | * @return void |
| 3195: | * @static |
| 3196: | */ |
| 3197: | public static function assertDispatchedSync($command, $callback = null) |
| 3198: | { |
| 3199: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3200: | $instance->assertDispatchedSync($command, $callback); |
| 3201: | } |
| 3202: | /** |
| 3203: | * Assert if a job was pushed synchronously a number of times. |
| 3204: | * |
| 3205: | * @param string $command |
| 3206: | * @param int $times |
| 3207: | * @return void |
| 3208: | * @static |
| 3209: | */ |
| 3210: | public static function assertDispatchedSyncTimes($command, $times = 1) |
| 3211: | { |
| 3212: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3213: | $instance->assertDispatchedSyncTimes($command, $times); |
| 3214: | } |
| 3215: | /** |
| 3216: | * Determine if a job was dispatched based on a truth-test callback. |
| 3217: | * |
| 3218: | * @param string|\Closure $command |
| 3219: | * @param callable|null $callback |
| 3220: | * @return void |
| 3221: | * @static |
| 3222: | */ |
| 3223: | public static function assertNotDispatchedSync($command, $callback = null) |
| 3224: | { |
| 3225: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3226: | $instance->assertNotDispatchedSync($command, $callback); |
| 3227: | } |
| 3228: | /** |
| 3229: | * Assert if a job was dispatched after the response was sent based on a truth-test callback. |
| 3230: | * |
| 3231: | * @param string|\Closure $command |
| 3232: | * @param callable|int|null $callback |
| 3233: | * @return void |
| 3234: | * @static |
| 3235: | */ |
| 3236: | public static function assertDispatchedAfterResponse($command, $callback = null) |
| 3237: | { |
| 3238: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3239: | $instance->assertDispatchedAfterResponse($command, $callback); |
| 3240: | } |
| 3241: | /** |
| 3242: | * Assert if a job was pushed after the response was sent a number of times. |
| 3243: | * |
| 3244: | * @param string $command |
| 3245: | * @param int $times |
| 3246: | * @return void |
| 3247: | * @static |
| 3248: | */ |
| 3249: | public static function assertDispatchedAfterResponseTimes($command, $times = 1) |
| 3250: | { |
| 3251: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3252: | $instance->assertDispatchedAfterResponseTimes($command, $times); |
| 3253: | } |
| 3254: | /** |
| 3255: | * Determine if a job was dispatched based on a truth-test callback. |
| 3256: | * |
| 3257: | * @param string|\Closure $command |
| 3258: | * @param callable|null $callback |
| 3259: | * @return void |
| 3260: | * @static |
| 3261: | */ |
| 3262: | public static function assertNotDispatchedAfterResponse($command, $callback = null) |
| 3263: | { |
| 3264: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3265: | $instance->assertNotDispatchedAfterResponse($command, $callback); |
| 3266: | } |
| 3267: | /** |
| 3268: | * Assert if a chain of jobs was dispatched. |
| 3269: | * |
| 3270: | * @param array $expectedChain |
| 3271: | * @return void |
| 3272: | * @static |
| 3273: | */ |
| 3274: | public static function assertChained($expectedChain) |
| 3275: | { |
| 3276: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3277: | $instance->assertChained($expectedChain); |
| 3278: | } |
| 3279: | /** |
| 3280: | * Assert if a job was dispatched with an empty chain based on a truth-test callback. |
| 3281: | * |
| 3282: | * @param string|\Closure $command |
| 3283: | * @param callable|null $callback |
| 3284: | * @return void |
| 3285: | * @static |
| 3286: | */ |
| 3287: | public static function assertDispatchedWithoutChain($command, $callback = null) |
| 3288: | { |
| 3289: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3290: | $instance->assertDispatchedWithoutChain($command, $callback); |
| 3291: | } |
| 3292: | /** |
| 3293: | * Assert if a batch was dispatched based on a truth-test callback. |
| 3294: | * |
| 3295: | * @param callable $callback |
| 3296: | * @return void |
| 3297: | * @static |
| 3298: | */ |
| 3299: | public static function assertBatched($callback) |
| 3300: | { |
| 3301: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3302: | $instance->assertBatched($callback); |
| 3303: | } |
| 3304: | /** |
| 3305: | * Assert the number of batches that have been dispatched. |
| 3306: | * |
| 3307: | * @param int $count |
| 3308: | * @return void |
| 3309: | * @static |
| 3310: | */ |
| 3311: | public static function assertBatchCount($count) |
| 3312: | { |
| 3313: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3314: | $instance->assertBatchCount($count); |
| 3315: | } |
| 3316: | /** |
| 3317: | * Get all of the jobs matching a truth-test callback. |
| 3318: | * |
| 3319: | * @param string $command |
| 3320: | * @param callable|null $callback |
| 3321: | * @return \Illuminate\Support\Collection |
| 3322: | * @static |
| 3323: | */ |
| 3324: | public static function dispatched($command, $callback = null) |
| 3325: | { |
| 3326: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3327: | return $instance->dispatched($command, $callback); |
| 3328: | } |
| 3329: | /** |
| 3330: | * Get all of the jobs dispatched synchronously matching a truth-test callback. |
| 3331: | * |
| 3332: | * @param string $command |
| 3333: | * @param callable|null $callback |
| 3334: | * @return \Illuminate\Support\Collection |
| 3335: | * @static |
| 3336: | */ |
| 3337: | public static function dispatchedSync($command, $callback = null) |
| 3338: | { |
| 3339: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3340: | return $instance->dispatchedSync($command, $callback); |
| 3341: | } |
| 3342: | /** |
| 3343: | * Get all of the jobs dispatched after the response was sent matching a truth-test callback. |
| 3344: | * |
| 3345: | * @param string $command |
| 3346: | * @param callable|null $callback |
| 3347: | * @return \Illuminate\Support\Collection |
| 3348: | * @static |
| 3349: | */ |
| 3350: | public static function dispatchedAfterResponse($command, $callback = null) |
| 3351: | { |
| 3352: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3353: | return $instance->dispatchedAfterResponse($command, $callback); |
| 3354: | } |
| 3355: | /** |
| 3356: | * Get all of the pending batches matching a truth-test callback. |
| 3357: | * |
| 3358: | * @param callable $callback |
| 3359: | * @return \Illuminate\Support\Collection |
| 3360: | * @static |
| 3361: | */ |
| 3362: | public static function batched($callback) |
| 3363: | { |
| 3364: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3365: | return $instance->batched($callback); |
| 3366: | } |
| 3367: | /** |
| 3368: | * Determine if there are any stored commands for a given class. |
| 3369: | * |
| 3370: | * @param string $command |
| 3371: | * @return bool |
| 3372: | * @static |
| 3373: | */ |
| 3374: | public static function hasDispatched($command) |
| 3375: | { |
| 3376: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3377: | return $instance->hasDispatched($command); |
| 3378: | } |
| 3379: | /** |
| 3380: | * Determine if there are any stored commands for a given class. |
| 3381: | * |
| 3382: | * @param string $command |
| 3383: | * @return bool |
| 3384: | * @static |
| 3385: | */ |
| 3386: | public static function hasDispatchedSync($command) |
| 3387: | { |
| 3388: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3389: | return $instance->hasDispatchedSync($command); |
| 3390: | } |
| 3391: | /** |
| 3392: | * Determine if there are any stored commands for a given class. |
| 3393: | * |
| 3394: | * @param string $command |
| 3395: | * @return bool |
| 3396: | * @static |
| 3397: | */ |
| 3398: | public static function hasDispatchedAfterResponse($command) |
| 3399: | { |
| 3400: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3401: | return $instance->hasDispatchedAfterResponse($command); |
| 3402: | } |
| 3403: | /** |
| 3404: | * Record the fake pending batch dispatch. |
| 3405: | * |
| 3406: | * @param \Illuminate\Bus\PendingBatch $pendingBatch |
| 3407: | * @return \Illuminate\Bus\Batch |
| 3408: | * @static |
| 3409: | */ |
| 3410: | public static function recordPendingBatch($pendingBatch) |
| 3411: | { |
| 3412: | /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */ |
| 3413: | return $instance->recordPendingBatch($pendingBatch); |
| 3414: | } |
| 3415: | |
| 3416: | } |
| 3417: | /** |
| 3418: | * |
| 3419: | * |
| 3420: | * @see \Illuminate\Cache\CacheManager |
| 3421: | * @see \Illuminate\Cache\Repository |
| 3422: | */ |
| 3423: | class Cache { |
| 3424: | /** |
| 3425: | * Get a cache store instance by name, wrapped in a repository. |
| 3426: | * |
| 3427: | * @param string|null $name |
| 3428: | * @return \Illuminate\Contracts\Cache\Repository |
| 3429: | * @static |
| 3430: | */ |
| 3431: | public static function store($name = null) |
| 3432: | { |
| 3433: | /** @var \Illuminate\Cache\CacheManager $instance */ |
| 3434: | return $instance->store($name); |
| 3435: | } |
| 3436: | /** |
| 3437: | * Get a cache driver instance. |
| 3438: | * |
| 3439: | * @param string|null $driver |
| 3440: | * @return \Illuminate\Contracts\Cache\Repository |
| 3441: | * @static |
| 3442: | */ |
| 3443: | public static function driver($driver = null) |
| 3444: | { |
| 3445: | /** @var \Illuminate\Cache\CacheManager $instance */ |
| 3446: | return $instance->driver($driver); |
| 3447: | } |
| 3448: | /** |
| 3449: | * Create a new cache repository with the given implementation. |
| 3450: | * |
| 3451: | * @param \Illuminate\Contracts\Cache\Store $store |
| 3452: | * @return \Illuminate\Cache\Repository |
| 3453: | * @static |
| 3454: | */ |
| 3455: | public static function repository($store) |
| 3456: | { |
| 3457: | /** @var \Illuminate\Cache\CacheManager $instance */ |
| 3458: | return $instance->repository($store); |
| 3459: | } |
| 3460: | /** |
| 3461: | * Re-set the event dispatcher on all resolved cache repositories. |
| 3462: | * |
| 3463: | * @return void |
| 3464: | * @static |
| 3465: | */ |
| 3466: | public static function refreshEventDispatcher() |
| 3467: | { |
| 3468: | /** @var \Illuminate\Cache\CacheManager $instance */ |
| 3469: | $instance->refreshEventDispatcher(); |
| 3470: | } |
| 3471: | /** |
| 3472: | * Get the default cache driver name. |
| 3473: | * |
| 3474: | * @return string |
| 3475: | * @static |
| 3476: | */ |
| 3477: | public static function getDefaultDriver() |
| 3478: | { |
| 3479: | /** @var \Illuminate\Cache\CacheManager $instance */ |
| 3480: | return $instance->getDefaultDriver(); |
| 3481: | } |
| 3482: | /** |
| 3483: | * Set the default cache driver name. |
| 3484: | * |
| 3485: | * @param string $name |
| 3486: | * @return void |
| 3487: | * @static |
| 3488: | */ |
| 3489: | public static function setDefaultDriver($name) |
| 3490: | { |
| 3491: | /** @var \Illuminate\Cache\CacheManager $instance */ |
| 3492: | $instance->setDefaultDriver($name); |
| 3493: | } |
| 3494: | /** |
| 3495: | * Unset the given driver instances. |
| 3496: | * |
| 3497: | * @param array|string|null $name |
| 3498: | * @return \Illuminate\Cache\CacheManager |
| 3499: | * @static |
| 3500: | */ |
| 3501: | public static function forgetDriver($name = null) |
| 3502: | { |
| 3503: | /** @var \Illuminate\Cache\CacheManager $instance */ |
| 3504: | return $instance->forgetDriver($name); |
| 3505: | } |
| 3506: | /** |
| 3507: | * Disconnect the given driver and remove from local cache. |
| 3508: | * |
| 3509: | * @param string|null $name |
| 3510: | * @return void |
| 3511: | * @static |
| 3512: | */ |
| 3513: | public static function purge($name = null) |
| 3514: | { |
| 3515: | /** @var \Illuminate\Cache\CacheManager $instance */ |
| 3516: | $instance->purge($name); |
| 3517: | } |
| 3518: | /** |
| 3519: | * Register a custom driver creator Closure. |
| 3520: | * |
| 3521: | * @param string $driver |
| 3522: | * @param \Closure $callback |
| 3523: | * @return \Illuminate\Cache\CacheManager |
| 3524: | * @static |
| 3525: | */ |
| 3526: | public static function extend($driver, $callback) |
| 3527: | { |
| 3528: | /** @var \Illuminate\Cache\CacheManager $instance */ |
| 3529: | return $instance->extend($driver, $callback); |
| 3530: | } |
| 3531: | /** |
| 3532: | * Determine if an item exists in the cache. |
| 3533: | * |
| 3534: | * @param string $key |
| 3535: | * @return bool |
| 3536: | * @static |
| 3537: | */ |
| 3538: | public static function has($key) |
| 3539: | { |
| 3540: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3541: | return $instance->has($key); |
| 3542: | } |
| 3543: | /** |
| 3544: | * Determine if an item doesn't exist in the cache. |
| 3545: | * |
| 3546: | * @param string $key |
| 3547: | * @return bool |
| 3548: | * @static |
| 3549: | */ |
| 3550: | public static function missing($key) |
| 3551: | { |
| 3552: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3553: | return $instance->missing($key); |
| 3554: | } |
| 3555: | /** |
| 3556: | * Retrieve an item from the cache by key. |
| 3557: | * |
| 3558: | * @param array|string $key |
| 3559: | * @param mixed $default |
| 3560: | * @return mixed |
| 3561: | * @static |
| 3562: | */ |
| 3563: | public static function get($key, $default = null) |
| 3564: | { |
| 3565: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3566: | return $instance->get($key, $default); |
| 3567: | } |
| 3568: | /** |
| 3569: | * Retrieve multiple items from the cache by key. |
| 3570: | * |
| 3571: | * Items not found in the cache will have a null value. |
| 3572: | * |
| 3573: | * @param array $keys |
| 3574: | * @return array |
| 3575: | * @static |
| 3576: | */ |
| 3577: | public static function many($keys) |
| 3578: | { |
| 3579: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3580: | return $instance->many($keys); |
| 3581: | } |
| 3582: | /** |
| 3583: | * Obtains multiple cache items by their unique keys. |
| 3584: | * |
| 3585: | * @return \Illuminate\Cache\iterable |
| 3586: | * @param \Psr\SimpleCache\iterable<string> $keys A list of keys that can be obtained in a single operation. |
| 3587: | * @param mixed $default Default value to return for keys that do not exist. |
| 3588: | * @return \Psr\SimpleCache\iterable<string, mixed> A list of key => value pairs. Cache keys that do not exist or are stale will have $default as value. |
| 3589: | * @throws \Psr\SimpleCache\InvalidArgumentException |
| 3590: | * MUST be thrown if $keys is neither an array nor a Traversable, |
| 3591: | * or if any of the $keys are not a legal value. |
| 3592: | * @static |
| 3593: | */ |
| 3594: | public static function getMultiple($keys, $default = null) |
| 3595: | { |
| 3596: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3597: | return $instance->getMultiple($keys, $default); |
| 3598: | } |
| 3599: | /** |
| 3600: | * Retrieve an item from the cache and delete it. |
| 3601: | * |
| 3602: | * @param string $key |
| 3603: | * @param mixed $default |
| 3604: | * @return mixed |
| 3605: | * @static |
| 3606: | */ |
| 3607: | public static function pull($key, $default = null) |
| 3608: | { |
| 3609: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3610: | return $instance->pull($key, $default); |
| 3611: | } |
| 3612: | /** |
| 3613: | * Store an item in the cache. |
| 3614: | * |
| 3615: | * @param array|string $key |
| 3616: | * @param mixed $value |
| 3617: | * @param \DateTimeInterface|\DateInterval|int|null $ttl |
| 3618: | * @return bool |
| 3619: | * @static |
| 3620: | */ |
| 3621: | public static function put($key, $value, $ttl = null) |
| 3622: | { |
| 3623: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3624: | return $instance->put($key, $value, $ttl); |
| 3625: | } |
| 3626: | /** |
| 3627: | * Persists data in the cache, uniquely referenced by a key with an optional expiration TTL time. |
| 3628: | * |
| 3629: | * @return bool |
| 3630: | * @param string $key The key of the item to store. |
| 3631: | * @param mixed $value The value of the item to store, must be serializable. |
| 3632: | * @param null|int|\DateInterval $ttl Optional. The TTL value of this item. If no value is sent and |
| 3633: | * the driver supports TTL then the library may set a default value |
| 3634: | * for it or let the driver take care of that. |
| 3635: | * @return bool True on success and false on failure. |
| 3636: | * @throws \Psr\SimpleCache\InvalidArgumentException |
| 3637: | * MUST be thrown if the $key string is not a legal value. |
| 3638: | * @static |
| 3639: | */ |
| 3640: | public static function set($key, $value, $ttl = null) |
| 3641: | { |
| 3642: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3643: | return $instance->set($key, $value, $ttl); |
| 3644: | } |
| 3645: | /** |
| 3646: | * Store multiple items in the cache for a given number of seconds. |
| 3647: | * |
| 3648: | * @param array $values |
| 3649: | * @param \DateTimeInterface|\DateInterval|int|null $ttl |
| 3650: | * @return bool |
| 3651: | * @static |
| 3652: | */ |
| 3653: | public static function putMany($values, $ttl = null) |
| 3654: | { |
| 3655: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3656: | return $instance->putMany($values, $ttl); |
| 3657: | } |
| 3658: | /** |
| 3659: | * Persists a set of key => value pairs in the cache, with an optional TTL. |
| 3660: | * |
| 3661: | * @return bool |
| 3662: | * @param \Psr\SimpleCache\iterable $values A list of key => value pairs for a multiple-set operation. |
| 3663: | * @param null|int|\DateInterval $ttl Optional. The TTL value of this item. If no value is sent and |
| 3664: | * the driver supports TTL then the library may set a default value |
| 3665: | * for it or let the driver take care of that. |
| 3666: | * @return bool True on success and false on failure. |
| 3667: | * @throws \Psr\SimpleCache\InvalidArgumentException |
| 3668: | * MUST be thrown if $values is neither an array nor a Traversable, |
| 3669: | * or if any of the $values are not a legal value. |
| 3670: | * @static |
| 3671: | */ |
| 3672: | public static function setMultiple($values, $ttl = null) |
| 3673: | { |
| 3674: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3675: | return $instance->setMultiple($values, $ttl); |
| 3676: | } |
| 3677: | /** |
| 3678: | * Store an item in the cache if the key does not exist. |
| 3679: | * |
| 3680: | * @param string $key |
| 3681: | * @param mixed $value |
| 3682: | * @param \DateTimeInterface|\DateInterval|int|null $ttl |
| 3683: | * @return bool |
| 3684: | * @static |
| 3685: | */ |
| 3686: | public static function add($key, $value, $ttl = null) |
| 3687: | { |
| 3688: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3689: | return $instance->add($key, $value, $ttl); |
| 3690: | } |
| 3691: | /** |
| 3692: | * Increment the value of an item in the cache. |
| 3693: | * |
| 3694: | * @param string $key |
| 3695: | * @param mixed $value |
| 3696: | * @return int|bool |
| 3697: | * @static |
| 3698: | */ |
| 3699: | public static function increment($key, $value = 1) |
| 3700: | { |
| 3701: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3702: | return $instance->increment($key, $value); |
| 3703: | } |
| 3704: | /** |
| 3705: | * Decrement the value of an item in the cache. |
| 3706: | * |
| 3707: | * @param string $key |
| 3708: | * @param mixed $value |
| 3709: | * @return int|bool |
| 3710: | * @static |
| 3711: | */ |
| 3712: | public static function decrement($key, $value = 1) |
| 3713: | { |
| 3714: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3715: | return $instance->decrement($key, $value); |
| 3716: | } |
| 3717: | /** |
| 3718: | * Store an item in the cache indefinitely. |
| 3719: | * |
| 3720: | * @param string $key |
| 3721: | * @param mixed $value |
| 3722: | * @return bool |
| 3723: | * @static |
| 3724: | */ |
| 3725: | public static function forever($key, $value) |
| 3726: | { |
| 3727: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3728: | return $instance->forever($key, $value); |
| 3729: | } |
| 3730: | /** |
| 3731: | * Get an item from the cache, or execute the given Closure and store the result. |
| 3732: | * |
| 3733: | * @param string $key |
| 3734: | * @param \Closure|\DateTimeInterface|\DateInterval|int|null $ttl |
| 3735: | * @param \Closure $callback |
| 3736: | * @return mixed |
| 3737: | * @static |
| 3738: | */ |
| 3739: | public static function remember($key, $ttl, $callback) |
| 3740: | { |
| 3741: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3742: | return $instance->remember($key, $ttl, $callback); |
| 3743: | } |
| 3744: | /** |
| 3745: | * Get an item from the cache, or execute the given Closure and store the result forever. |
| 3746: | * |
| 3747: | * @param string $key |
| 3748: | * @param \Closure $callback |
| 3749: | * @return mixed |
| 3750: | * @static |
| 3751: | */ |
| 3752: | public static function sear($key, $callback) |
| 3753: | { |
| 3754: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3755: | return $instance->sear($key, $callback); |
| 3756: | } |
| 3757: | /** |
| 3758: | * Get an item from the cache, or execute the given Closure and store the result forever. |
| 3759: | * |
| 3760: | * @param string $key |
| 3761: | * @param \Closure $callback |
| 3762: | * @return mixed |
| 3763: | * @static |
| 3764: | */ |
| 3765: | public static function rememberForever($key, $callback) |
| 3766: | { |
| 3767: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3768: | return $instance->rememberForever($key, $callback); |
| 3769: | } |
| 3770: | /** |
| 3771: | * Remove an item from the cache. |
| 3772: | * |
| 3773: | * @param string $key |
| 3774: | * @return bool |
| 3775: | * @static |
| 3776: | */ |
| 3777: | public static function forget($key) |
| 3778: | { |
| 3779: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3780: | return $instance->forget($key); |
| 3781: | } |
| 3782: | /** |
| 3783: | * Delete an item from the cache by its unique key. |
| 3784: | * |
| 3785: | * @return bool |
| 3786: | * @param string $key The unique cache key of the item to delete. |
| 3787: | * @return bool True if the item was successfully removed. False if there was an error. |
| 3788: | * @throws \Psr\SimpleCache\InvalidArgumentException |
| 3789: | * MUST be thrown if the $key string is not a legal value. |
| 3790: | * @static |
| 3791: | */ |
| 3792: | public static function delete($key) |
| 3793: | { |
| 3794: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3795: | return $instance->delete($key); |
| 3796: | } |
| 3797: | /** |
| 3798: | * Deletes multiple cache items in a single operation. |
| 3799: | * |
| 3800: | * @return bool |
| 3801: | * @param \Psr\SimpleCache\iterable<string> $keys A list of string-based keys to be deleted. |
| 3802: | * @return bool True if the items were successfully removed. False if there was an error. |
| 3803: | * @throws \Psr\SimpleCache\InvalidArgumentException |
| 3804: | * MUST be thrown if $keys is neither an array nor a Traversable, |
| 3805: | * or if any of the $keys are not a legal value. |
| 3806: | * @static |
| 3807: | */ |
| 3808: | public static function deleteMultiple($keys) |
| 3809: | { |
| 3810: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3811: | return $instance->deleteMultiple($keys); |
| 3812: | } |
| 3813: | /** |
| 3814: | * Wipes clean the entire cache's keys. |
| 3815: | * |
| 3816: | * @return bool |
| 3817: | * @return bool True on success and false on failure. |
| 3818: | * @static |
| 3819: | */ |
| 3820: | public static function clear() |
| 3821: | { |
| 3822: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3823: | return $instance->clear(); |
| 3824: | } |
| 3825: | /** |
| 3826: | * Begin executing a new tags operation if the store supports it. |
| 3827: | * |
| 3828: | * @param array|mixed $names |
| 3829: | * @return \Illuminate\Cache\TaggedCache |
| 3830: | * @throws \BadMethodCallException |
| 3831: | * @static |
| 3832: | */ |
| 3833: | public static function tags($names) |
| 3834: | { |
| 3835: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3836: | return $instance->tags($names); |
| 3837: | } |
| 3838: | /** |
| 3839: | * Determine if the current store supports tags. |
| 3840: | * |
| 3841: | * @return bool |
| 3842: | * @static |
| 3843: | */ |
| 3844: | public static function supportsTags() |
| 3845: | { |
| 3846: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3847: | return $instance->supportsTags(); |
| 3848: | } |
| 3849: | /** |
| 3850: | * Get the default cache time. |
| 3851: | * |
| 3852: | * @return int|null |
| 3853: | * @static |
| 3854: | */ |
| 3855: | public static function getDefaultCacheTime() |
| 3856: | { |
| 3857: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3858: | return $instance->getDefaultCacheTime(); |
| 3859: | } |
| 3860: | /** |
| 3861: | * Set the default cache time in seconds. |
| 3862: | * |
| 3863: | * @param int|null $seconds |
| 3864: | * @return \Illuminate\Cache\Repository |
| 3865: | * @static |
| 3866: | */ |
| 3867: | public static function setDefaultCacheTime($seconds) |
| 3868: | { |
| 3869: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3870: | return $instance->setDefaultCacheTime($seconds); |
| 3871: | } |
| 3872: | /** |
| 3873: | * Get the cache store implementation. |
| 3874: | * |
| 3875: | * @return \Illuminate\Contracts\Cache\Store |
| 3876: | * @static |
| 3877: | */ |
| 3878: | public static function getStore() |
| 3879: | { |
| 3880: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3881: | return $instance->getStore(); |
| 3882: | } |
| 3883: | /** |
| 3884: | * Get the event dispatcher instance. |
| 3885: | * |
| 3886: | * @return \Illuminate\Contracts\Events\Dispatcher |
| 3887: | * @static |
| 3888: | */ |
| 3889: | public static function getEventDispatcher() |
| 3890: | { |
| 3891: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3892: | return $instance->getEventDispatcher(); |
| 3893: | } |
| 3894: | /** |
| 3895: | * Set the event dispatcher instance. |
| 3896: | * |
| 3897: | * @param \Illuminate\Contracts\Events\Dispatcher $events |
| 3898: | * @return void |
| 3899: | * @static |
| 3900: | */ |
| 3901: | public static function setEventDispatcher($events) |
| 3902: | { |
| 3903: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3904: | $instance->setEventDispatcher($events); |
| 3905: | } |
| 3906: | /** |
| 3907: | * Determine if a cached value exists. |
| 3908: | * |
| 3909: | * @param string $key |
| 3910: | * @return bool |
| 3911: | * @static |
| 3912: | */ |
| 3913: | public static function offsetExists($key) |
| 3914: | { |
| 3915: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3916: | return $instance->offsetExists($key); |
| 3917: | } |
| 3918: | /** |
| 3919: | * Retrieve an item from the cache by key. |
| 3920: | * |
| 3921: | * @param string $key |
| 3922: | * @return mixed |
| 3923: | * @static |
| 3924: | */ |
| 3925: | public static function offsetGet($key) |
| 3926: | { |
| 3927: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3928: | return $instance->offsetGet($key); |
| 3929: | } |
| 3930: | /** |
| 3931: | * Store an item in the cache for the default time. |
| 3932: | * |
| 3933: | * @param string $key |
| 3934: | * @param mixed $value |
| 3935: | * @return void |
| 3936: | * @static |
| 3937: | */ |
| 3938: | public static function offsetSet($key, $value) |
| 3939: | { |
| 3940: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3941: | $instance->offsetSet($key, $value); |
| 3942: | } |
| 3943: | /** |
| 3944: | * Remove an item from the cache. |
| 3945: | * |
| 3946: | * @param string $key |
| 3947: | * @return void |
| 3948: | * @static |
| 3949: | */ |
| 3950: | public static function offsetUnset($key) |
| 3951: | { |
| 3952: | /** @var \Illuminate\Cache\Repository $instance */ |
| 3953: | $instance->offsetUnset($key); |
| 3954: | } |
| 3955: | /** |
| 3956: | * Register a custom macro. |
| 3957: | * |
| 3958: | * @param string $name |
| 3959: | * @param object|callable $macro |
| 3960: | * @return void |
| 3961: | * @static |
| 3962: | */ |
| 3963: | public static function macro($name, $macro) |
| 3964: | { |
| 3965: | \Illuminate\Cache\Repository::macro($name, $macro); |
| 3966: | } |
| 3967: | /** |
| 3968: | * Mix another object into the class. |
| 3969: | * |
| 3970: | * @param object $mixin |
| 3971: | * @param bool $replace |
| 3972: | * @return void |
| 3973: | * @throws \ReflectionException |
| 3974: | * @static |
| 3975: | */ |
| 3976: | public static function mixin($mixin, $replace = true) |
| 3977: | { |
| 3978: | \Illuminate\Cache\Repository::mixin($mixin, $replace); |
| 3979: | } |
| 3980: | /** |
| 3981: | * Checks if macro is registered. |
| 3982: | * |
| 3983: | * @param string $name |
| 3984: | * @return bool |
| 3985: | * @static |
| 3986: | */ |
| 3987: | public static function hasMacro($name) |
| 3988: | { |
| 3989: | return \Illuminate\Cache\Repository::hasMacro($name); |
| 3990: | } |
| 3991: | /** |
| 3992: | * Flush the existing macros. |
| 3993: | * |
| 3994: | * @return void |
| 3995: | * @static |
| 3996: | */ |
| 3997: | public static function flushMacros() |
| 3998: | { |
| 3999: | \Illuminate\Cache\Repository::flushMacros(); |
| 4000: | } |
| 4001: | /** |
| 4002: | * Dynamically handle calls to the class. |
| 4003: | * |
| 4004: | * @param string $method |
| 4005: | * @param array $parameters |
| 4006: | * @return mixed |
| 4007: | * @throws \BadMethodCallException |
| 4008: | * @static |
| 4009: | */ |
| 4010: | public static function macroCall($method, $parameters) |
| 4011: | { |
| 4012: | /** @var \Illuminate\Cache\Repository $instance */ |
| 4013: | return $instance->macroCall($method, $parameters); |
| 4014: | } |
| 4015: | /** |
| 4016: | * Remove all items from the cache. |
| 4017: | * |
| 4018: | * @return bool |
| 4019: | * @static |
| 4020: | */ |
| 4021: | public static function flush() |
| 4022: | { |
| 4023: | /** @var \Illuminate\Cache\FileStore $instance */ |
| 4024: | return $instance->flush(); |
| 4025: | } |
| 4026: | /** |
| 4027: | * Get the Filesystem instance. |
| 4028: | * |
| 4029: | * @return \Illuminate\Filesystem\Filesystem |
| 4030: | * @static |
| 4031: | */ |
| 4032: | public static function getFilesystem() |
| 4033: | { |
| 4034: | /** @var \Illuminate\Cache\FileStore $instance */ |
| 4035: | return $instance->getFilesystem(); |
| 4036: | } |
| 4037: | /** |
| 4038: | * Get the working directory of the cache. |
| 4039: | * |
| 4040: | * @return string |
| 4041: | * @static |
| 4042: | */ |
| 4043: | public static function getDirectory() |
| 4044: | { |
| 4045: | /** @var \Illuminate\Cache\FileStore $instance */ |
| 4046: | return $instance->getDirectory(); |
| 4047: | } |
| 4048: | /** |
| 4049: | * Get the cache key prefix. |
| 4050: | * |
| 4051: | * @return string |
| 4052: | * @static |
| 4053: | */ |
| 4054: | public static function getPrefix() |
| 4055: | { |
| 4056: | /** @var \Illuminate\Cache\FileStore $instance */ |
| 4057: | return $instance->getPrefix(); |
| 4058: | } |
| 4059: | /** |
| 4060: | * Get a lock instance. |
| 4061: | * |
| 4062: | * @param string $name |
| 4063: | * @param int $seconds |
| 4064: | * @param string|null $owner |
| 4065: | * @return \Illuminate\Contracts\Cache\Lock |
| 4066: | * @static |
| 4067: | */ |
| 4068: | public static function lock($name, $seconds = 0, $owner = null) |
| 4069: | { |
| 4070: | /** @var \Illuminate\Cache\FileStore $instance */ |
| 4071: | return $instance->lock($name, $seconds, $owner); |
| 4072: | } |
| 4073: | /** |
| 4074: | * Restore a lock instance using the owner identifier. |
| 4075: | * |
| 4076: | * @param string $name |
| 4077: | * @param string $owner |
| 4078: | * @return \Illuminate\Contracts\Cache\Lock |
| 4079: | * @static |
| 4080: | */ |
| 4081: | public static function restoreLock($name, $owner) |
| 4082: | { |
| 4083: | /** @var \Illuminate\Cache\FileStore $instance */ |
| 4084: | return $instance->restoreLock($name, $owner); |
| 4085: | } |
| 4086: | |
| 4087: | } |
| 4088: | /** |
| 4089: | * |
| 4090: | * |
| 4091: | * @see \Illuminate\Config\Repository |
| 4092: | */ |
| 4093: | class Config { |
| 4094: | /** |
| 4095: | * Determine if the given configuration value exists. |
| 4096: | * |
| 4097: | * @param string $key |
| 4098: | * @return bool |
| 4099: | * @static |
| 4100: | */ |
| 4101: | public static function has($key) |
| 4102: | { |
| 4103: | /** @var \Illuminate\Config\Repository $instance */ |
| 4104: | return $instance->has($key); |
| 4105: | } |
| 4106: | /** |
| 4107: | * Get the specified configuration value. |
| 4108: | * |
| 4109: | * @param array|string $key |
| 4110: | * @param mixed $default |
| 4111: | * @return mixed |
| 4112: | * @static |
| 4113: | */ |
| 4114: | public static function get($key, $default = null) |
| 4115: | { |
| 4116: | /** @var \Illuminate\Config\Repository $instance */ |
| 4117: | return $instance->get($key, $default); |
| 4118: | } |
| 4119: | /** |
| 4120: | * Get many configuration values. |
| 4121: | * |
| 4122: | * @param array $keys |
| 4123: | * @return array |
| 4124: | * @static |
| 4125: | */ |
| 4126: | public static function getMany($keys) |
| 4127: | { |
| 4128: | /** @var \Illuminate\Config\Repository $instance */ |
| 4129: | return $instance->getMany($keys); |
| 4130: | } |
| 4131: | /** |
| 4132: | * Set a given configuration value. |
| 4133: | * |
| 4134: | * @param array|string $key |
| 4135: | * @param mixed $value |
| 4136: | * @return void |
| 4137: | * @static |
| 4138: | */ |
| 4139: | public static function set($key, $value = null) |
| 4140: | { |
| 4141: | /** @var \Illuminate\Config\Repository $instance */ |
| 4142: | $instance->set($key, $value); |
| 4143: | } |
| 4144: | /** |
| 4145: | * Prepend a value onto an array configuration value. |
| 4146: | * |
| 4147: | * @param string $key |
| 4148: | * @param mixed $value |
| 4149: | * @return void |
| 4150: | * @static |
| 4151: | */ |
| 4152: | public static function prepend($key, $value) |
| 4153: | { |
| 4154: | /** @var \Illuminate\Config\Repository $instance */ |
| 4155: | $instance->prepend($key, $value); |
| 4156: | } |
| 4157: | /** |
| 4158: | * Push a value onto an array configuration value. |
| 4159: | * |
| 4160: | * @param string $key |
| 4161: | * @param mixed $value |
| 4162: | * @return void |
| 4163: | * @static |
| 4164: | */ |
| 4165: | public static function push($key, $value) |
| 4166: | { |
| 4167: | /** @var \Illuminate\Config\Repository $instance */ |
| 4168: | $instance->push($key, $value); |
| 4169: | } |
| 4170: | /** |
| 4171: | * Get all of the configuration items for the application. |
| 4172: | * |
| 4173: | * @return array |
| 4174: | * @static |
| 4175: | */ |
| 4176: | public static function all() |
| 4177: | { |
| 4178: | /** @var \Illuminate\Config\Repository $instance */ |
| 4179: | return $instance->all(); |
| 4180: | } |
| 4181: | /** |
| 4182: | * Determine if the given configuration option exists. |
| 4183: | * |
| 4184: | * @param string $key |
| 4185: | * @return bool |
| 4186: | * @static |
| 4187: | */ |
| 4188: | public static function offsetExists($key) |
| 4189: | { |
| 4190: | /** @var \Illuminate\Config\Repository $instance */ |
| 4191: | return $instance->offsetExists($key); |
| 4192: | } |
| 4193: | /** |
| 4194: | * Get a configuration option. |
| 4195: | * |
| 4196: | * @param string $key |
| 4197: | * @return mixed |
| 4198: | * @static |
| 4199: | */ |
| 4200: | public static function offsetGet($key) |
| 4201: | { |
| 4202: | /** @var \Illuminate\Config\Repository $instance */ |
| 4203: | return $instance->offsetGet($key); |
| 4204: | } |
| 4205: | /** |
| 4206: | * Set a configuration option. |
| 4207: | * |
| 4208: | * @param string $key |
| 4209: | * @param mixed $value |
| 4210: | * @return void |
| 4211: | * @static |
| 4212: | */ |
| 4213: | public static function offsetSet($key, $value) |
| 4214: | { |
| 4215: | /** @var \Illuminate\Config\Repository $instance */ |
| 4216: | $instance->offsetSet($key, $value); |
| 4217: | } |
| 4218: | /** |
| 4219: | * Unset a configuration option. |
| 4220: | * |
| 4221: | * @param string $key |
| 4222: | * @return void |
| 4223: | * @static |
| 4224: | */ |
| 4225: | public static function offsetUnset($key) |
| 4226: | { |
| 4227: | /** @var \Illuminate\Config\Repository $instance */ |
| 4228: | $instance->offsetUnset($key); |
| 4229: | } |
| 4230: | |
| 4231: | } |
| 4232: | /** |
| 4233: | * |
| 4234: | * |
| 4235: | * @see \Illuminate\Cookie\CookieJar |
| 4236: | */ |
| 4237: | class Cookie { |
| 4238: | /** |
| 4239: | * Create a new cookie instance. |
| 4240: | * |
| 4241: | * @param string $name |
| 4242: | * @param string $value |
| 4243: | * @param int $minutes |
| 4244: | * @param string|null $path |
| 4245: | * @param string|null $domain |
| 4246: | * @param bool|null $secure |
| 4247: | * @param bool $httpOnly |
| 4248: | * @param bool $raw |
| 4249: | * @param string|null $sameSite |
| 4250: | * @return \Symfony\Component\HttpFoundation\Cookie |
| 4251: | * @static |
| 4252: | */ |
| 4253: | public static function make($name, $value, $minutes = 0, $path = null, $domain = null, $secure = null, $httpOnly = true, $raw = false, $sameSite = null) |
| 4254: | { |
| 4255: | /** @var \Illuminate\Cookie\CookieJar $instance */ |
| 4256: | return $instance->make($name, $value, $minutes, $path, $domain, $secure, $httpOnly, $raw, $sameSite); |
| 4257: | } |
| 4258: | /** |
| 4259: | * Create a cookie that lasts "forever" (five years). |
| 4260: | * |
| 4261: | * @param string $name |
| 4262: | * @param string $value |
| 4263: | * @param string|null $path |
| 4264: | * @param string|null $domain |
| 4265: | * @param bool|null $secure |
| 4266: | * @param bool $httpOnly |
| 4267: | * @param bool $raw |
| 4268: | * @param string|null $sameSite |
| 4269: | * @return \Symfony\Component\HttpFoundation\Cookie |
| 4270: | * @static |
| 4271: | */ |
| 4272: | public static function forever($name, $value, $path = null, $domain = null, $secure = null, $httpOnly = true, $raw = false, $sameSite = null) |
| 4273: | { |
| 4274: | /** @var \Illuminate\Cookie\CookieJar $instance */ |
| 4275: | return $instance->forever($name, $value, $path, $domain, $secure, $httpOnly, $raw, $sameSite); |
| 4276: | } |
| 4277: | /** |
| 4278: | * Expire the given cookie. |
| 4279: | * |
| 4280: | * @param string $name |
| 4281: | * @param string|null $path |
| 4282: | * @param string|null $domain |
| 4283: | * @return \Symfony\Component\HttpFoundation\Cookie |
| 4284: | * @static |
| 4285: | */ |
| 4286: | public static function forget($name, $path = null, $domain = null) |
| 4287: | { |
| 4288: | /** @var \Illuminate\Cookie\CookieJar $instance */ |
| 4289: | return $instance->forget($name, $path, $domain); |
| 4290: | } |
| 4291: | /** |
| 4292: | * Determine if a cookie has been queued. |
| 4293: | * |
| 4294: | * @param string $key |
| 4295: | * @param string|null $path |
| 4296: | * @return bool |
| 4297: | * @static |
| 4298: | */ |
| 4299: | public static function hasQueued($key, $path = null) |
| 4300: | { |
| 4301: | /** @var \Illuminate\Cookie\CookieJar $instance */ |
| 4302: | return $instance->hasQueued($key, $path); |
| 4303: | } |
| 4304: | /** |
| 4305: | * Get a queued cookie instance. |
| 4306: | * |
| 4307: | * @param string $key |
| 4308: | * @param mixed $default |
| 4309: | * @param string|null $path |
| 4310: | * @return \Symfony\Component\HttpFoundation\Cookie|null |
| 4311: | * @static |
| 4312: | */ |
| 4313: | public static function queued($key, $default = null, $path = null) |
| 4314: | { |
| 4315: | /** @var \Illuminate\Cookie\CookieJar $instance */ |
| 4316: | return $instance->queued($key, $default, $path); |
| 4317: | } |
| 4318: | /** |
| 4319: | * Queue a cookie to send with the next response. |
| 4320: | * |
| 4321: | * @param array $parameters |
| 4322: | * @return void |
| 4323: | * @static |
| 4324: | */ |
| 4325: | public static function queue(...$parameters) |
| 4326: | { |
| 4327: | /** @var \Illuminate\Cookie\CookieJar $instance */ |
| 4328: | $instance->queue(...$parameters); |
| 4329: | } |
| 4330: | /** |
| 4331: | * Queue a cookie to expire with the next response. |
| 4332: | * |
| 4333: | * @param string $name |
| 4334: | * @param string|null $path |
| 4335: | * @param string|null $domain |
| 4336: | * @return void |
| 4337: | * @static |
| 4338: | */ |
| 4339: | public static function expire($name, $path = null, $domain = null) |
| 4340: | { |
| 4341: | /** @var \Illuminate\Cookie\CookieJar $instance */ |
| 4342: | $instance->expire($name, $path, $domain); |
| 4343: | } |
| 4344: | /** |
| 4345: | * Remove a cookie from the queue. |
| 4346: | * |
| 4347: | * @param string $name |
| 4348: | * @param string|null $path |
| 4349: | * @return void |
| 4350: | * @static |
| 4351: | */ |
| 4352: | public static function unqueue($name, $path = null) |
| 4353: | { |
| 4354: | /** @var \Illuminate\Cookie\CookieJar $instance */ |
| 4355: | $instance->unqueue($name, $path); |
| 4356: | } |
| 4357: | /** |
| 4358: | * Set the default path and domain for the jar. |
| 4359: | * |
| 4360: | * @param string $path |
| 4361: | * @param string $domain |
| 4362: | * @param bool $secure |
| 4363: | * @param string|null $sameSite |
| 4364: | * @return \Illuminate\Cookie\CookieJar |
| 4365: | * @static |
| 4366: | */ |
| 4367: | public static function setDefaultPathAndDomain($path, $domain, $secure = false, $sameSite = null) |
| 4368: | { |
| 4369: | /** @var \Illuminate\Cookie\CookieJar $instance */ |
| 4370: | return $instance->setDefaultPathAndDomain($path, $domain, $secure, $sameSite); |
| 4371: | } |
| 4372: | /** |
| 4373: | * Get the cookies which have been queued for the next request. |
| 4374: | * |
| 4375: | * @return \Symfony\Component\HttpFoundation\Cookie[] |
| 4376: | * @static |
| 4377: | */ |
| 4378: | public static function getQueuedCookies() |
| 4379: | { |
| 4380: | /** @var \Illuminate\Cookie\CookieJar $instance */ |
| 4381: | return $instance->getQueuedCookies(); |
| 4382: | } |
| 4383: | /** |
| 4384: | * Flush the cookies which have been queued for the next request. |
| 4385: | * |
| 4386: | * @return \Illuminate\Cookie\CookieJar |
| 4387: | * @static |
| 4388: | */ |
| 4389: | public static function flushQueuedCookies() |
| 4390: | { |
| 4391: | /** @var \Illuminate\Cookie\CookieJar $instance */ |
| 4392: | return $instance->flushQueuedCookies(); |
| 4393: | } |
| 4394: | /** |
| 4395: | * Register a custom macro. |
| 4396: | * |
| 4397: | * @param string $name |
| 4398: | * @param object|callable $macro |
| 4399: | * @return void |
| 4400: | * @static |
| 4401: | */ |
| 4402: | public static function macro($name, $macro) |
| 4403: | { |
| 4404: | \Illuminate\Cookie\CookieJar::macro($name, $macro); |
| 4405: | } |
| 4406: | /** |
| 4407: | * Mix another object into the class. |
| 4408: | * |
| 4409: | * @param object $mixin |
| 4410: | * @param bool $replace |
| 4411: | * @return void |
| 4412: | * @throws \ReflectionException |
| 4413: | * @static |
| 4414: | */ |
| 4415: | public static function mixin($mixin, $replace = true) |
| 4416: | { |
| 4417: | \Illuminate\Cookie\CookieJar::mixin($mixin, $replace); |
| 4418: | } |
| 4419: | /** |
| 4420: | * Checks if macro is registered. |
| 4421: | * |
| 4422: | * @param string $name |
| 4423: | * @return bool |
| 4424: | * @static |
| 4425: | */ |
| 4426: | public static function hasMacro($name) |
| 4427: | { |
| 4428: | return \Illuminate\Cookie\CookieJar::hasMacro($name); |
| 4429: | } |
| 4430: | /** |
| 4431: | * Flush the existing macros. |
| 4432: | * |
| 4433: | * @return void |
| 4434: | * @static |
| 4435: | */ |
| 4436: | public static function flushMacros() |
| 4437: | { |
| 4438: | \Illuminate\Cookie\CookieJar::flushMacros(); |
| 4439: | } |
| 4440: | |
| 4441: | } |
| 4442: | /** |
| 4443: | * |
| 4444: | * |
| 4445: | * @see \Illuminate\Encryption\Encrypter |
| 4446: | */ |
| 4447: | class Crypt { |
| 4448: | /** |
| 4449: | * Determine if the given key and cipher combination is valid. |
| 4450: | * |
| 4451: | * @param string $key |
| 4452: | * @param string $cipher |
| 4453: | * @return bool |
| 4454: | * @static |
| 4455: | */ |
| 4456: | public static function supported($key, $cipher) |
| 4457: | { |
| 4458: | return \Illuminate\Encryption\Encrypter::supported($key, $cipher); |
| 4459: | } |
| 4460: | /** |
| 4461: | * Create a new encryption key for the given cipher. |
| 4462: | * |
| 4463: | * @param string $cipher |
| 4464: | * @return string |
| 4465: | * @static |
| 4466: | */ |
| 4467: | public static function generateKey($cipher) |
| 4468: | { |
| 4469: | return \Illuminate\Encryption\Encrypter::generateKey($cipher); |
| 4470: | } |
| 4471: | /** |
| 4472: | * Encrypt the given value. |
| 4473: | * |
| 4474: | * @param mixed $value |
| 4475: | * @param bool $serialize |
| 4476: | * @return string |
| 4477: | * @throws \Illuminate\Contracts\Encryption\EncryptException |
| 4478: | * @static |
| 4479: | */ |
| 4480: | public static function encrypt($value, $serialize = true) |
| 4481: | { |
| 4482: | /** @var \Illuminate\Encryption\Encrypter $instance */ |
| 4483: | return $instance->encrypt($value, $serialize); |
| 4484: | } |
| 4485: | /** |
| 4486: | * Encrypt a string without serialization. |
| 4487: | * |
| 4488: | * @param string $value |
| 4489: | * @return string |
| 4490: | * @throws \Illuminate\Contracts\Encryption\EncryptException |
| 4491: | * @static |
| 4492: | */ |
| 4493: | public static function encryptString($value) |
| 4494: | { |
| 4495: | /** @var \Illuminate\Encryption\Encrypter $instance */ |
| 4496: | return $instance->encryptString($value); |
| 4497: | } |
| 4498: | /** |
| 4499: | * Decrypt the given value. |
| 4500: | * |
| 4501: | * @param string $payload |
| 4502: | * @param bool $unserialize |
| 4503: | * @return mixed |
| 4504: | * @throws \Illuminate\Contracts\Encryption\DecryptException |
| 4505: | * @static |
| 4506: | */ |
| 4507: | public static function decrypt($payload, $unserialize = true) |
| 4508: | { |
| 4509: | /** @var \Illuminate\Encryption\Encrypter $instance */ |
| 4510: | return $instance->decrypt($payload, $unserialize); |
| 4511: | } |
| 4512: | /** |
| 4513: | * Decrypt the given string without unserialization. |
| 4514: | * |
| 4515: | * @param string $payload |
| 4516: | * @return string |
| 4517: | * @throws \Illuminate\Contracts\Encryption\DecryptException |
| 4518: | * @static |
| 4519: | */ |
| 4520: | public static function decryptString($payload) |
| 4521: | { |
| 4522: | /** @var \Illuminate\Encryption\Encrypter $instance */ |
| 4523: | return $instance->decryptString($payload); |
| 4524: | } |
| 4525: | /** |
| 4526: | * Get the encryption key that the encrypter is currently using. |
| 4527: | * |
| 4528: | * @return string |
| 4529: | * @static |
| 4530: | */ |
| 4531: | public static function getKey() |
| 4532: | { |
| 4533: | /** @var \Illuminate\Encryption\Encrypter $instance */ |
| 4534: | return $instance->getKey(); |
| 4535: | } |
| 4536: | |
| 4537: | } |
| 4538: | /** |
| 4539: | * |
| 4540: | * |
| 4541: | * @see https://carbon.nesbot.com/docs/ |
| 4542: | * @see https://github.com/briannesbitt/Carbon/blob/master/src/Carbon/Factory.php |
| 4543: | * @method static \Illuminate\Support\Carbon create($year = 0, $month = 1, $day = 1, $hour = 0, $minute = 0, $second = 0, $tz = null) |
| 4544: | * @method static \Illuminate\Support\Carbon createFromDate($year = null, $month = null, $day = null, $tz = null) |
| 4545: | * @method static \Illuminate\Support\Carbon createFromTime($hour = 0, $minute = 0, $second = 0, $tz = null) |
| 4546: | * @method static \Illuminate\Support\Carbon createFromTimeString($time, $tz = null) |
| 4547: | * @method static \Illuminate\Support\Carbon createFromTimestamp($timestamp, $tz = null) |
| 4548: | * @method static \Illuminate\Support\Carbon createFromTimestampMs($timestamp, $tz = null) |
| 4549: | * @method static \Illuminate\Support\Carbon createFromTimestampUTC($timestamp) |
| 4550: | * @method static \Illuminate\Support\Carbon createMidnightDate($year = null, $month = null, $day = null, $tz = null) |
| 4551: | * @method static void disableHumanDiffOption($humanDiffOption) |
| 4552: | * @method static void enableHumanDiffOption($humanDiffOption) |
| 4553: | * @method static \Illuminate\Support\Carbon fromSerialized($value) |
| 4554: | * @method static array getLastErrors() |
| 4555: | * @method static \Illuminate\Support\Carbon|null getTestNow() |
| 4556: | * @method static \Illuminate\Support\Carbon instance($date) |
| 4557: | * @method static bool isMutable() |
| 4558: | * @method static \Illuminate\Support\Carbon maxValue() |
| 4559: | * @method static \Illuminate\Support\Carbon minValue() |
| 4560: | * @method static \Illuminate\Support\Carbon now($tz = null) |
| 4561: | * @method static \Illuminate\Support\Carbon parse($time = null, $tz = null) |
| 4562: | * @method static void setHumanDiffOptions($humanDiffOptions) |
| 4563: | * @method static void setTestNow($testNow = null) |
| 4564: | * @method static void setUtf8($utf8) |
| 4565: | * @method static \Illuminate\Support\Carbon today($tz = null) |
| 4566: | * @method static \Illuminate\Support\Carbon tomorrow($tz = null) |
| 4567: | * @method static void useStrictMode($strictModeEnabled = true) |
| 4568: | * @method static \Illuminate\Support\Carbon yesterday($tz = null) |
| 4569: | * @method static \Illuminate\Support\Carbon|false createFromFormat($format, $time, $tz = null) |
| 4570: | * @method static \Illuminate\Support\Carbon|false createSafe($year = null, $month = null, $day = null, $hour = null, $minute = null, $second = null, $tz = null) |
| 4571: | * @method static \Illuminate\Support\Carbon|null make($var) |
| 4572: | * @method static \Symfony\Component\Translation\TranslatorInterface getTranslator() |
| 4573: | * @method static array getAvailableLocales() |
| 4574: | * @method static array getDays() |
| 4575: | * @method static array getIsoUnits() |
| 4576: | * @method static array getWeekendDays() |
| 4577: | * @method static bool hasFormat($date, $format) |
| 4578: | * @method static bool hasMacro($name) |
| 4579: | * @method static bool hasRelativeKeywords($time) |
| 4580: | * @method static bool hasTestNow() |
| 4581: | * @method static bool isImmutable() |
| 4582: | * @method static bool isModifiableUnit($unit) |
| 4583: | * @method static bool isStrictModeEnabled() |
| 4584: | * @method static bool localeHasDiffOneDayWords($locale) |
| 4585: | * @method static bool localeHasDiffSyntax($locale) |
| 4586: | * @method static bool localeHasDiffTwoDayWords($locale) |
| 4587: | * @method static bool localeHasPeriodSyntax($locale) |
| 4588: | * @method static bool localeHasShortUnits($locale) |
| 4589: | * @method static bool setLocale($locale) |
| 4590: | * @method static bool shouldOverflowMonths() |
| 4591: | * @method static bool shouldOverflowYears() |
| 4592: | * @method static int getHumanDiffOptions() |
| 4593: | * @method static int getMidDayAt() |
| 4594: | * @method static int getWeekEndsAt() |
| 4595: | * @method static int getWeekStartsAt() |
| 4596: | * @method static mixed executeWithLocale($locale, $func) |
| 4597: | * @method static string getLocale() |
| 4598: | * @method static string pluralUnit(string $unit) |
| 4599: | * @method static string singularUnit(string $unit) |
| 4600: | * @method static void macro($name, $macro) |
| 4601: | * @method static void mixin($mixin) |
| 4602: | * @method static void resetMonthsOverflow() |
| 4603: | * @method static void resetToStringFormat() |
| 4604: | * @method static void resetYearsOverflow() |
| 4605: | * @method static void serializeUsing($callback) |
| 4606: | * @method static void setMidDayAt($hour) |
| 4607: | * @method static void setToStringFormat($format) |
| 4608: | * @method static void setTranslator(\Symfony\Component\Translation\TranslatorInterface $translator) |
| 4609: | * @method static void setWeekEndsAt($day) |
| 4610: | * @method static void setWeekStartsAt($day) |
| 4611: | * @method static void setWeekendDays($days) |
| 4612: | * @method static void useMonthsOverflow($monthsOverflow = true) |
| 4613: | * @method static void useYearsOverflow($yearsOverflow = true) |
| 4614: | */ |
| 4615: | class Date { |
| 4616: | /** |
| 4617: | * Use the given handler when generating dates (class name, callable, or factory). |
| 4618: | * |
| 4619: | * @param mixed $handler |
| 4620: | * @return mixed |
| 4621: | * @throws \InvalidArgumentException |
| 4622: | * @static |
| 4623: | */ |
| 4624: | public static function use($handler) |
| 4625: | { |
| 4626: | return \Illuminate\Support\DateFactory::use($handler); |
| 4627: | } |
| 4628: | /** |
| 4629: | * Use the default date class when generating dates. |
| 4630: | * |
| 4631: | * @return void |
| 4632: | * @static |
| 4633: | */ |
| 4634: | public static function useDefault() |
| 4635: | { |
| 4636: | \Illuminate\Support\DateFactory::useDefault(); |
| 4637: | } |
| 4638: | /** |
| 4639: | * Execute the given callable on each date creation. |
| 4640: | * |
| 4641: | * @param callable $callable |
| 4642: | * @return void |
| 4643: | * @static |
| 4644: | */ |
| 4645: | public static function useCallable($callable) |
| 4646: | { |
| 4647: | \Illuminate\Support\DateFactory::useCallable($callable); |
| 4648: | } |
| 4649: | /** |
| 4650: | * Use the given date type (class) when generating dates. |
| 4651: | * |
| 4652: | * @param string $dateClass |
| 4653: | * @return void |
| 4654: | * @static |
| 4655: | */ |
| 4656: | public static function useClass($dateClass) |
| 4657: | { |
| 4658: | \Illuminate\Support\DateFactory::useClass($dateClass); |
| 4659: | } |
| 4660: | /** |
| 4661: | * Use the given Carbon factory when generating dates. |
| 4662: | * |
| 4663: | * @param object $factory |
| 4664: | * @return void |
| 4665: | * @static |
| 4666: | */ |
| 4667: | public static function useFactory($factory) |
| 4668: | { |
| 4669: | \Illuminate\Support\DateFactory::useFactory($factory); |
| 4670: | } |
| 4671: | |
| 4672: | } |
| 4673: | /** |
| 4674: | * |
| 4675: | * |
| 4676: | * @see \Illuminate\Database\DatabaseManager |
| 4677: | * @see \Illuminate\Database\Connection |
| 4678: | */ |
| 4679: | class DB { |
| 4680: | /** |
| 4681: | * Get a database connection instance. |
| 4682: | * |
| 4683: | * @param string|null $name |
| 4684: | * @return \Illuminate\Database\Connection |
| 4685: | * @static |
| 4686: | */ |
| 4687: | public static function connection($name = null) |
| 4688: | { |
| 4689: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4690: | return $instance->connection($name); |
| 4691: | } |
| 4692: | /** |
| 4693: | * Register a custom Doctrine type. |
| 4694: | * |
| 4695: | * @param string $class |
| 4696: | * @param string $name |
| 4697: | * @param string $type |
| 4698: | * @return void |
| 4699: | * @throws \Doctrine\DBAL\DBALException |
| 4700: | * @throws \RuntimeException |
| 4701: | * @static |
| 4702: | */ |
| 4703: | public static function registerDoctrineType($class, $name, $type) |
| 4704: | { |
| 4705: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4706: | $instance->registerDoctrineType($class, $name, $type); |
| 4707: | } |
| 4708: | /** |
| 4709: | * Disconnect from the given database and remove from local cache. |
| 4710: | * |
| 4711: | * @param string|null $name |
| 4712: | * @return void |
| 4713: | * @static |
| 4714: | */ |
| 4715: | public static function purge($name = null) |
| 4716: | { |
| 4717: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4718: | $instance->purge($name); |
| 4719: | } |
| 4720: | /** |
| 4721: | * Disconnect from the given database. |
| 4722: | * |
| 4723: | * @param string|null $name |
| 4724: | * @return void |
| 4725: | * @static |
| 4726: | */ |
| 4727: | public static function disconnect($name = null) |
| 4728: | { |
| 4729: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4730: | $instance->disconnect($name); |
| 4731: | } |
| 4732: | /** |
| 4733: | * Reconnect to the given database. |
| 4734: | * |
| 4735: | * @param string|null $name |
| 4736: | * @return \Illuminate\Database\Connection |
| 4737: | * @static |
| 4738: | */ |
| 4739: | public static function reconnect($name = null) |
| 4740: | { |
| 4741: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4742: | return $instance->reconnect($name); |
| 4743: | } |
| 4744: | /** |
| 4745: | * Set the default database connection for the callback execution. |
| 4746: | * |
| 4747: | * @param string $name |
| 4748: | * @param callable $callback |
| 4749: | * @return mixed |
| 4750: | * @static |
| 4751: | */ |
| 4752: | public static function usingConnection($name, $callback) |
| 4753: | { |
| 4754: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4755: | return $instance->usingConnection($name, $callback); |
| 4756: | } |
| 4757: | /** |
| 4758: | * Get the default connection name. |
| 4759: | * |
| 4760: | * @return string |
| 4761: | * @static |
| 4762: | */ |
| 4763: | public static function getDefaultConnection() |
| 4764: | { |
| 4765: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4766: | return $instance->getDefaultConnection(); |
| 4767: | } |
| 4768: | /** |
| 4769: | * Set the default connection name. |
| 4770: | * |
| 4771: | * @param string $name |
| 4772: | * @return void |
| 4773: | * @static |
| 4774: | */ |
| 4775: | public static function setDefaultConnection($name) |
| 4776: | { |
| 4777: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4778: | $instance->setDefaultConnection($name); |
| 4779: | } |
| 4780: | /** |
| 4781: | * Get all of the support drivers. |
| 4782: | * |
| 4783: | * @return string[] |
| 4784: | * @static |
| 4785: | */ |
| 4786: | public static function supportedDrivers() |
| 4787: | { |
| 4788: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4789: | return $instance->supportedDrivers(); |
| 4790: | } |
| 4791: | /** |
| 4792: | * Get all of the drivers that are actually available. |
| 4793: | * |
| 4794: | * @return string[] |
| 4795: | * @static |
| 4796: | */ |
| 4797: | public static function availableDrivers() |
| 4798: | { |
| 4799: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4800: | return $instance->availableDrivers(); |
| 4801: | } |
| 4802: | /** |
| 4803: | * Register an extension connection resolver. |
| 4804: | * |
| 4805: | * @param string $name |
| 4806: | * @param callable $resolver |
| 4807: | * @return void |
| 4808: | * @static |
| 4809: | */ |
| 4810: | public static function extend($name, $resolver) |
| 4811: | { |
| 4812: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4813: | $instance->extend($name, $resolver); |
| 4814: | } |
| 4815: | /** |
| 4816: | * Remove an extension connection resolver. |
| 4817: | * |
| 4818: | * @param string $name |
| 4819: | * @return void |
| 4820: | * @static |
| 4821: | */ |
| 4822: | public static function forgetExtension($name) |
| 4823: | { |
| 4824: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4825: | $instance->forgetExtension($name); |
| 4826: | } |
| 4827: | /** |
| 4828: | * Return all of the created connections. |
| 4829: | * |
| 4830: | * @return \Illuminate\Database\array<string, \Illuminate\Database\Connection> |
| 4831: | * @static |
| 4832: | */ |
| 4833: | public static function getConnections() |
| 4834: | { |
| 4835: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4836: | return $instance->getConnections(); |
| 4837: | } |
| 4838: | /** |
| 4839: | * Set the database reconnector callback. |
| 4840: | * |
| 4841: | * @param callable $reconnector |
| 4842: | * @return void |
| 4843: | * @static |
| 4844: | */ |
| 4845: | public static function setReconnector($reconnector) |
| 4846: | { |
| 4847: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4848: | $instance->setReconnector($reconnector); |
| 4849: | } |
| 4850: | /** |
| 4851: | * Set the application instance used by the manager. |
| 4852: | * |
| 4853: | * @param \Illuminate\Contracts\Foundation\Application $app |
| 4854: | * @return \Illuminate\Database\DatabaseManager |
| 4855: | * @static |
| 4856: | */ |
| 4857: | public static function setApplication($app) |
| 4858: | { |
| 4859: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4860: | return $instance->setApplication($app); |
| 4861: | } |
| 4862: | /** |
| 4863: | * Register a custom macro. |
| 4864: | * |
| 4865: | * @param string $name |
| 4866: | * @param object|callable $macro |
| 4867: | * @return void |
| 4868: | * @static |
| 4869: | */ |
| 4870: | public static function macro($name, $macro) |
| 4871: | { |
| 4872: | \Illuminate\Database\DatabaseManager::macro($name, $macro); |
| 4873: | } |
| 4874: | /** |
| 4875: | * Mix another object into the class. |
| 4876: | * |
| 4877: | * @param object $mixin |
| 4878: | * @param bool $replace |
| 4879: | * @return void |
| 4880: | * @throws \ReflectionException |
| 4881: | * @static |
| 4882: | */ |
| 4883: | public static function mixin($mixin, $replace = true) |
| 4884: | { |
| 4885: | \Illuminate\Database\DatabaseManager::mixin($mixin, $replace); |
| 4886: | } |
| 4887: | /** |
| 4888: | * Checks if macro is registered. |
| 4889: | * |
| 4890: | * @param string $name |
| 4891: | * @return bool |
| 4892: | * @static |
| 4893: | */ |
| 4894: | public static function hasMacro($name) |
| 4895: | { |
| 4896: | return \Illuminate\Database\DatabaseManager::hasMacro($name); |
| 4897: | } |
| 4898: | /** |
| 4899: | * Flush the existing macros. |
| 4900: | * |
| 4901: | * @return void |
| 4902: | * @static |
| 4903: | */ |
| 4904: | public static function flushMacros() |
| 4905: | { |
| 4906: | \Illuminate\Database\DatabaseManager::flushMacros(); |
| 4907: | } |
| 4908: | /** |
| 4909: | * Dynamically handle calls to the class. |
| 4910: | * |
| 4911: | * @param string $method |
| 4912: | * @param array $parameters |
| 4913: | * @return mixed |
| 4914: | * @throws \BadMethodCallException |
| 4915: | * @static |
| 4916: | */ |
| 4917: | public static function macroCall($method, $parameters) |
| 4918: | { |
| 4919: | /** @var \Illuminate\Database\DatabaseManager $instance */ |
| 4920: | return $instance->macroCall($method, $parameters); |
| 4921: | } |
| 4922: | /** |
| 4923: | * Determine if the connected database is a MariaDB database. |
| 4924: | * |
| 4925: | * @return bool |
| 4926: | * @static |
| 4927: | */ |
| 4928: | public static function isMaria() |
| 4929: | { |
| 4930: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 4931: | return $instance->isMaria(); |
| 4932: | } |
| 4933: | /** |
| 4934: | * Get a schema builder instance for the connection. |
| 4935: | * |
| 4936: | * @return \Illuminate\Database\Schema\MySqlBuilder |
| 4937: | * @static |
| 4938: | */ |
| 4939: | public static function getSchemaBuilder() |
| 4940: | { |
| 4941: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 4942: | return $instance->getSchemaBuilder(); |
| 4943: | } |
| 4944: | /** |
| 4945: | * Get the schema state for the connection. |
| 4946: | * |
| 4947: | * @param \Illuminate\Filesystem\Filesystem|null $files |
| 4948: | * @param callable|null $processFactory |
| 4949: | * @return \Illuminate\Database\Schema\MySqlSchemaState |
| 4950: | * @static |
| 4951: | */ |
| 4952: | public static function getSchemaState($files = null, $processFactory = null) |
| 4953: | { |
| 4954: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 4955: | return $instance->getSchemaState($files, $processFactory); |
| 4956: | } |
| 4957: | /** |
| 4958: | * Set the query grammar to the default implementation. |
| 4959: | * |
| 4960: | * @return void |
| 4961: | * @static |
| 4962: | */ |
| 4963: | public static function useDefaultQueryGrammar() |
| 4964: | { //Method inherited from \Illuminate\Database\Connection |
| 4965: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 4966: | $instance->useDefaultQueryGrammar(); |
| 4967: | } |
| 4968: | /** |
| 4969: | * Set the schema grammar to the default implementation. |
| 4970: | * |
| 4971: | * @return void |
| 4972: | * @static |
| 4973: | */ |
| 4974: | public static function useDefaultSchemaGrammar() |
| 4975: | { //Method inherited from \Illuminate\Database\Connection |
| 4976: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 4977: | $instance->useDefaultSchemaGrammar(); |
| 4978: | } |
| 4979: | /** |
| 4980: | * Set the query post processor to the default implementation. |
| 4981: | * |
| 4982: | * @return void |
| 4983: | * @static |
| 4984: | */ |
| 4985: | public static function useDefaultPostProcessor() |
| 4986: | { //Method inherited from \Illuminate\Database\Connection |
| 4987: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 4988: | $instance->useDefaultPostProcessor(); |
| 4989: | } |
| 4990: | /** |
| 4991: | * Begin a fluent query against a database table. |
| 4992: | * |
| 4993: | * @param \Closure|\Illuminate\Database\Query\Builder|string $table |
| 4994: | * @param string|null $as |
| 4995: | * @return \Illuminate\Database\Query\Builder |
| 4996: | * @static |
| 4997: | */ |
| 4998: | public static function table($table, $as = null) |
| 4999: | { //Method inherited from \Illuminate\Database\Connection |
| 5000: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5001: | return $instance->table($table, $as); |
| 5002: | } |
| 5003: | /** |
| 5004: | * Get a new query builder instance. |
| 5005: | * |
| 5006: | * @return \Illuminate\Database\Query\Builder |
| 5007: | * @static |
| 5008: | */ |
| 5009: | public static function query() |
| 5010: | { //Method inherited from \Illuminate\Database\Connection |
| 5011: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5012: | return $instance->query(); |
| 5013: | } |
| 5014: | /** |
| 5015: | * Run a select statement and return a single result. |
| 5016: | * |
| 5017: | * @param string $query |
| 5018: | * @param array $bindings |
| 5019: | * @param bool $useReadPdo |
| 5020: | * @return mixed |
| 5021: | * @static |
| 5022: | */ |
| 5023: | public static function selectOne($query, $bindings = [], $useReadPdo = true) |
| 5024: | { //Method inherited from \Illuminate\Database\Connection |
| 5025: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5026: | return $instance->selectOne($query, $bindings, $useReadPdo); |
| 5027: | } |
| 5028: | /** |
| 5029: | * Run a select statement and return the first column of the first row. |
| 5030: | * |
| 5031: | * @param string $query |
| 5032: | * @param array $bindings |
| 5033: | * @param bool $useReadPdo |
| 5034: | * @return mixed |
| 5035: | * @throws \Illuminate\Database\MultipleColumnsSelectedException |
| 5036: | * @static |
| 5037: | */ |
| 5038: | public static function scalar($query, $bindings = [], $useReadPdo = true) |
| 5039: | { //Method inherited from \Illuminate\Database\Connection |
| 5040: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5041: | return $instance->scalar($query, $bindings, $useReadPdo); |
| 5042: | } |
| 5043: | /** |
| 5044: | * Run a select statement against the database. |
| 5045: | * |
| 5046: | * @param string $query |
| 5047: | * @param array $bindings |
| 5048: | * @return array |
| 5049: | * @static |
| 5050: | */ |
| 5051: | public static function selectFromWriteConnection($query, $bindings = []) |
| 5052: | { //Method inherited from \Illuminate\Database\Connection |
| 5053: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5054: | return $instance->selectFromWriteConnection($query, $bindings); |
| 5055: | } |
| 5056: | /** |
| 5057: | * Run a select statement against the database. |
| 5058: | * |
| 5059: | * @param string $query |
| 5060: | * @param array $bindings |
| 5061: | * @param bool $useReadPdo |
| 5062: | * @return array |
| 5063: | * @static |
| 5064: | */ |
| 5065: | public static function select($query, $bindings = [], $useReadPdo = true) |
| 5066: | { //Method inherited from \Illuminate\Database\Connection |
| 5067: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5068: | return $instance->select($query, $bindings, $useReadPdo); |
| 5069: | } |
| 5070: | /** |
| 5071: | * Run a select statement against the database and returns a generator. |
| 5072: | * |
| 5073: | * @param string $query |
| 5074: | * @param array $bindings |
| 5075: | * @param bool $useReadPdo |
| 5076: | * @return \Generator |
| 5077: | * @static |
| 5078: | */ |
| 5079: | public static function cursor($query, $bindings = [], $useReadPdo = true) |
| 5080: | { //Method inherited from \Illuminate\Database\Connection |
| 5081: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5082: | return $instance->cursor($query, $bindings, $useReadPdo); |
| 5083: | } |
| 5084: | /** |
| 5085: | * Run an insert statement against the database. |
| 5086: | * |
| 5087: | * @param string $query |
| 5088: | * @param array $bindings |
| 5089: | * @return bool |
| 5090: | * @static |
| 5091: | */ |
| 5092: | public static function insert($query, $bindings = []) |
| 5093: | { //Method inherited from \Illuminate\Database\Connection |
| 5094: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5095: | return $instance->insert($query, $bindings); |
| 5096: | } |
| 5097: | /** |
| 5098: | * Run an update statement against the database. |
| 5099: | * |
| 5100: | * @param string $query |
| 5101: | * @param array $bindings |
| 5102: | * @return int |
| 5103: | * @static |
| 5104: | */ |
| 5105: | public static function update($query, $bindings = []) |
| 5106: | { //Method inherited from \Illuminate\Database\Connection |
| 5107: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5108: | return $instance->update($query, $bindings); |
| 5109: | } |
| 5110: | /** |
| 5111: | * Run a delete statement against the database. |
| 5112: | * |
| 5113: | * @param string $query |
| 5114: | * @param array $bindings |
| 5115: | * @return int |
| 5116: | * @static |
| 5117: | */ |
| 5118: | public static function delete($query, $bindings = []) |
| 5119: | { //Method inherited from \Illuminate\Database\Connection |
| 5120: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5121: | return $instance->delete($query, $bindings); |
| 5122: | } |
| 5123: | /** |
| 5124: | * Execute an SQL statement and return the boolean result. |
| 5125: | * |
| 5126: | * @param string $query |
| 5127: | * @param array $bindings |
| 5128: | * @return bool |
| 5129: | * @static |
| 5130: | */ |
| 5131: | public static function statement($query, $bindings = []) |
| 5132: | { //Method inherited from \Illuminate\Database\Connection |
| 5133: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5134: | return $instance->statement($query, $bindings); |
| 5135: | } |
| 5136: | /** |
| 5137: | * Run an SQL statement and get the number of rows affected. |
| 5138: | * |
| 5139: | * @param string $query |
| 5140: | * @param array $bindings |
| 5141: | * @return int |
| 5142: | * @static |
| 5143: | */ |
| 5144: | public static function affectingStatement($query, $bindings = []) |
| 5145: | { //Method inherited from \Illuminate\Database\Connection |
| 5146: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5147: | return $instance->affectingStatement($query, $bindings); |
| 5148: | } |
| 5149: | /** |
| 5150: | * Run a raw, unprepared query against the PDO connection. |
| 5151: | * |
| 5152: | * @param string $query |
| 5153: | * @return bool |
| 5154: | * @static |
| 5155: | */ |
| 5156: | public static function unprepared($query) |
| 5157: | { //Method inherited from \Illuminate\Database\Connection |
| 5158: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5159: | return $instance->unprepared($query); |
| 5160: | } |
| 5161: | /** |
| 5162: | * Execute the given callback in "dry run" mode. |
| 5163: | * |
| 5164: | * @param \Closure $callback |
| 5165: | * @return array |
| 5166: | * @static |
| 5167: | */ |
| 5168: | public static function pretend($callback) |
| 5169: | { //Method inherited from \Illuminate\Database\Connection |
| 5170: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5171: | return $instance->pretend($callback); |
| 5172: | } |
| 5173: | /** |
| 5174: | * Bind values to their parameters in the given statement. |
| 5175: | * |
| 5176: | * @param \PDOStatement $statement |
| 5177: | * @param array $bindings |
| 5178: | * @return void |
| 5179: | * @static |
| 5180: | */ |
| 5181: | public static function bindValues($statement, $bindings) |
| 5182: | { //Method inherited from \Illuminate\Database\Connection |
| 5183: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5184: | $instance->bindValues($statement, $bindings); |
| 5185: | } |
| 5186: | /** |
| 5187: | * Prepare the query bindings for execution. |
| 5188: | * |
| 5189: | * @param array $bindings |
| 5190: | * @return array |
| 5191: | * @static |
| 5192: | */ |
| 5193: | public static function prepareBindings($bindings) |
| 5194: | { //Method inherited from \Illuminate\Database\Connection |
| 5195: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5196: | return $instance->prepareBindings($bindings); |
| 5197: | } |
| 5198: | /** |
| 5199: | * Log a query in the connection's query log. |
| 5200: | * |
| 5201: | * @param string $query |
| 5202: | * @param array $bindings |
| 5203: | * @param float|null $time |
| 5204: | * @return void |
| 5205: | * @static |
| 5206: | */ |
| 5207: | public static function logQuery($query, $bindings, $time = null) |
| 5208: | { //Method inherited from \Illuminate\Database\Connection |
| 5209: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5210: | $instance->logQuery($query, $bindings, $time); |
| 5211: | } |
| 5212: | /** |
| 5213: | * Register a callback to be invoked when the connection queries for longer than a given amount of time. |
| 5214: | * |
| 5215: | * @param \DateTimeInterface|\Carbon\CarbonInterval|float|int $threshold |
| 5216: | * @param callable $handler |
| 5217: | * @return void |
| 5218: | * @static |
| 5219: | */ |
| 5220: | public static function whenQueryingForLongerThan($threshold, $handler) |
| 5221: | { //Method inherited from \Illuminate\Database\Connection |
| 5222: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5223: | $instance->whenQueryingForLongerThan($threshold, $handler); |
| 5224: | } |
| 5225: | /** |
| 5226: | * Allow all the query duration handlers to run again, even if they have already run. |
| 5227: | * |
| 5228: | * @return void |
| 5229: | * @static |
| 5230: | */ |
| 5231: | public static function allowQueryDurationHandlersToRunAgain() |
| 5232: | { //Method inherited from \Illuminate\Database\Connection |
| 5233: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5234: | $instance->allowQueryDurationHandlersToRunAgain(); |
| 5235: | } |
| 5236: | /** |
| 5237: | * Get the duration of all run queries in milliseconds. |
| 5238: | * |
| 5239: | * @return float |
| 5240: | * @static |
| 5241: | */ |
| 5242: | public static function totalQueryDuration() |
| 5243: | { //Method inherited from \Illuminate\Database\Connection |
| 5244: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5245: | return $instance->totalQueryDuration(); |
| 5246: | } |
| 5247: | /** |
| 5248: | * Reset the duration of all run queries. |
| 5249: | * |
| 5250: | * @return void |
| 5251: | * @static |
| 5252: | */ |
| 5253: | public static function resetTotalQueryDuration() |
| 5254: | { //Method inherited from \Illuminate\Database\Connection |
| 5255: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5256: | $instance->resetTotalQueryDuration(); |
| 5257: | } |
| 5258: | /** |
| 5259: | * Register a hook to be run just before a database query is executed. |
| 5260: | * |
| 5261: | * @param \Closure $callback |
| 5262: | * @return \Illuminate\Database\MySqlConnection |
| 5263: | * @static |
| 5264: | */ |
| 5265: | public static function beforeExecuting($callback) |
| 5266: | { //Method inherited from \Illuminate\Database\Connection |
| 5267: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5268: | return $instance->beforeExecuting($callback); |
| 5269: | } |
| 5270: | /** |
| 5271: | * Register a database query listener with the connection. |
| 5272: | * |
| 5273: | * @param \Closure $callback |
| 5274: | * @return void |
| 5275: | * @static |
| 5276: | */ |
| 5277: | public static function listen($callback) |
| 5278: | { //Method inherited from \Illuminate\Database\Connection |
| 5279: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5280: | $instance->listen($callback); |
| 5281: | } |
| 5282: | /** |
| 5283: | * Get a new raw query expression. |
| 5284: | * |
| 5285: | * @param mixed $value |
| 5286: | * @return \Illuminate\Database\Query\Expression |
| 5287: | * @static |
| 5288: | */ |
| 5289: | public static function raw($value) |
| 5290: | { //Method inherited from \Illuminate\Database\Connection |
| 5291: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5292: | return $instance->raw($value); |
| 5293: | } |
| 5294: | /** |
| 5295: | * Determine if the database connection has modified any database records. |
| 5296: | * |
| 5297: | * @return bool |
| 5298: | * @static |
| 5299: | */ |
| 5300: | public static function hasModifiedRecords() |
| 5301: | { //Method inherited from \Illuminate\Database\Connection |
| 5302: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5303: | return $instance->hasModifiedRecords(); |
| 5304: | } |
| 5305: | /** |
| 5306: | * Indicate if any records have been modified. |
| 5307: | * |
| 5308: | * @param bool $value |
| 5309: | * @return void |
| 5310: | * @static |
| 5311: | */ |
| 5312: | public static function recordsHaveBeenModified($value = true) |
| 5313: | { //Method inherited from \Illuminate\Database\Connection |
| 5314: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5315: | $instance->recordsHaveBeenModified($value); |
| 5316: | } |
| 5317: | /** |
| 5318: | * Set the record modification state. |
| 5319: | * |
| 5320: | * @param bool $value |
| 5321: | * @return \Illuminate\Database\MySqlConnection |
| 5322: | * @static |
| 5323: | */ |
| 5324: | public static function setRecordModificationState($value) |
| 5325: | { //Method inherited from \Illuminate\Database\Connection |
| 5326: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5327: | return $instance->setRecordModificationState($value); |
| 5328: | } |
| 5329: | /** |
| 5330: | * Reset the record modification state. |
| 5331: | * |
| 5332: | * @return void |
| 5333: | * @static |
| 5334: | */ |
| 5335: | public static function forgetRecordModificationState() |
| 5336: | { //Method inherited from \Illuminate\Database\Connection |
| 5337: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5338: | $instance->forgetRecordModificationState(); |
| 5339: | } |
| 5340: | /** |
| 5341: | * Indicate that the connection should use the write PDO connection for reads. |
| 5342: | * |
| 5343: | * @param bool $value |
| 5344: | * @return \Illuminate\Database\MySqlConnection |
| 5345: | * @static |
| 5346: | */ |
| 5347: | public static function useWriteConnectionWhenReading($value = true) |
| 5348: | { //Method inherited from \Illuminate\Database\Connection |
| 5349: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5350: | return $instance->useWriteConnectionWhenReading($value); |
| 5351: | } |
| 5352: | /** |
| 5353: | * Is Doctrine available? |
| 5354: | * |
| 5355: | * @return bool |
| 5356: | * @static |
| 5357: | */ |
| 5358: | public static function isDoctrineAvailable() |
| 5359: | { //Method inherited from \Illuminate\Database\Connection |
| 5360: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5361: | return $instance->isDoctrineAvailable(); |
| 5362: | } |
| 5363: | /** |
| 5364: | * Get a Doctrine Schema Column instance. |
| 5365: | * |
| 5366: | * @param string $table |
| 5367: | * @param string $column |
| 5368: | * @return \Doctrine\DBAL\Schema\Column |
| 5369: | * @static |
| 5370: | */ |
| 5371: | public static function getDoctrineColumn($table, $column) |
| 5372: | { //Method inherited from \Illuminate\Database\Connection |
| 5373: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5374: | return $instance->getDoctrineColumn($table, $column); |
| 5375: | } |
| 5376: | /** |
| 5377: | * Get the Doctrine DBAL schema manager for the connection. |
| 5378: | * |
| 5379: | * @return \Doctrine\DBAL\Schema\AbstractSchemaManager |
| 5380: | * @static |
| 5381: | */ |
| 5382: | public static function getDoctrineSchemaManager() |
| 5383: | { //Method inherited from \Illuminate\Database\Connection |
| 5384: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5385: | return $instance->getDoctrineSchemaManager(); |
| 5386: | } |
| 5387: | /** |
| 5388: | * Get the Doctrine DBAL database connection instance. |
| 5389: | * |
| 5390: | * @return \Doctrine\DBAL\Connection |
| 5391: | * @static |
| 5392: | */ |
| 5393: | public static function getDoctrineConnection() |
| 5394: | { //Method inherited from \Illuminate\Database\Connection |
| 5395: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5396: | return $instance->getDoctrineConnection(); |
| 5397: | } |
| 5398: | /** |
| 5399: | * Get the current PDO connection. |
| 5400: | * |
| 5401: | * @return \PDO |
| 5402: | * @static |
| 5403: | */ |
| 5404: | public static function getPdo() |
| 5405: | { //Method inherited from \Illuminate\Database\Connection |
| 5406: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5407: | return $instance->getPdo(); |
| 5408: | } |
| 5409: | /** |
| 5410: | * Get the current PDO connection parameter without executing any reconnect logic. |
| 5411: | * |
| 5412: | * @return \PDO|\Closure|null |
| 5413: | * @static |
| 5414: | */ |
| 5415: | public static function getRawPdo() |
| 5416: | { //Method inherited from \Illuminate\Database\Connection |
| 5417: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5418: | return $instance->getRawPdo(); |
| 5419: | } |
| 5420: | /** |
| 5421: | * Get the current PDO connection used for reading. |
| 5422: | * |
| 5423: | * @return \PDO |
| 5424: | * @static |
| 5425: | */ |
| 5426: | public static function getReadPdo() |
| 5427: | { //Method inherited from \Illuminate\Database\Connection |
| 5428: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5429: | return $instance->getReadPdo(); |
| 5430: | } |
| 5431: | /** |
| 5432: | * Get the current read PDO connection parameter without executing any reconnect logic. |
| 5433: | * |
| 5434: | * @return \PDO|\Closure|null |
| 5435: | * @static |
| 5436: | */ |
| 5437: | public static function getRawReadPdo() |
| 5438: | { //Method inherited from \Illuminate\Database\Connection |
| 5439: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5440: | return $instance->getRawReadPdo(); |
| 5441: | } |
| 5442: | /** |
| 5443: | * Set the PDO connection. |
| 5444: | * |
| 5445: | * @param \PDO|\Closure|null $pdo |
| 5446: | * @return \Illuminate\Database\MySqlConnection |
| 5447: | * @static |
| 5448: | */ |
| 5449: | public static function setPdo($pdo) |
| 5450: | { //Method inherited from \Illuminate\Database\Connection |
| 5451: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5452: | return $instance->setPdo($pdo); |
| 5453: | } |
| 5454: | /** |
| 5455: | * Set the PDO connection used for reading. |
| 5456: | * |
| 5457: | * @param \PDO|\Closure|null $pdo |
| 5458: | * @return \Illuminate\Database\MySqlConnection |
| 5459: | * @static |
| 5460: | */ |
| 5461: | public static function setReadPdo($pdo) |
| 5462: | { //Method inherited from \Illuminate\Database\Connection |
| 5463: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5464: | return $instance->setReadPdo($pdo); |
| 5465: | } |
| 5466: | /** |
| 5467: | * Get the database connection name. |
| 5468: | * |
| 5469: | * @return string|null |
| 5470: | * @static |
| 5471: | */ |
| 5472: | public static function getName() |
| 5473: | { //Method inherited from \Illuminate\Database\Connection |
| 5474: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5475: | return $instance->getName(); |
| 5476: | } |
| 5477: | /** |
| 5478: | * Get the database connection full name. |
| 5479: | * |
| 5480: | * @return string|null |
| 5481: | * @static |
| 5482: | */ |
| 5483: | public static function getNameWithReadWriteType() |
| 5484: | { //Method inherited from \Illuminate\Database\Connection |
| 5485: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5486: | return $instance->getNameWithReadWriteType(); |
| 5487: | } |
| 5488: | /** |
| 5489: | * Get an option from the configuration options. |
| 5490: | * |
| 5491: | * @param string|null $option |
| 5492: | * @return mixed |
| 5493: | * @static |
| 5494: | */ |
| 5495: | public static function getConfig($option = null) |
| 5496: | { //Method inherited from \Illuminate\Database\Connection |
| 5497: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5498: | return $instance->getConfig($option); |
| 5499: | } |
| 5500: | /** |
| 5501: | * Get the PDO driver name. |
| 5502: | * |
| 5503: | * @return string |
| 5504: | * @static |
| 5505: | */ |
| 5506: | public static function getDriverName() |
| 5507: | { //Method inherited from \Illuminate\Database\Connection |
| 5508: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5509: | return $instance->getDriverName(); |
| 5510: | } |
| 5511: | /** |
| 5512: | * Get the query grammar used by the connection. |
| 5513: | * |
| 5514: | * @return \Illuminate\Database\Query\Grammars\Grammar |
| 5515: | * @static |
| 5516: | */ |
| 5517: | public static function getQueryGrammar() |
| 5518: | { //Method inherited from \Illuminate\Database\Connection |
| 5519: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5520: | return $instance->getQueryGrammar(); |
| 5521: | } |
| 5522: | /** |
| 5523: | * Set the query grammar used by the connection. |
| 5524: | * |
| 5525: | * @param \Illuminate\Database\Query\Grammars\Grammar $grammar |
| 5526: | * @return \Illuminate\Database\MySqlConnection |
| 5527: | * @static |
| 5528: | */ |
| 5529: | public static function setQueryGrammar($grammar) |
| 5530: | { //Method inherited from \Illuminate\Database\Connection |
| 5531: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5532: | return $instance->setQueryGrammar($grammar); |
| 5533: | } |
| 5534: | /** |
| 5535: | * Get the schema grammar used by the connection. |
| 5536: | * |
| 5537: | * @return \Illuminate\Database\Schema\Grammars\Grammar |
| 5538: | * @static |
| 5539: | */ |
| 5540: | public static function getSchemaGrammar() |
| 5541: | { //Method inherited from \Illuminate\Database\Connection |
| 5542: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5543: | return $instance->getSchemaGrammar(); |
| 5544: | } |
| 5545: | /** |
| 5546: | * Set the schema grammar used by the connection. |
| 5547: | * |
| 5548: | * @param \Illuminate\Database\Schema\Grammars\Grammar $grammar |
| 5549: | * @return \Illuminate\Database\MySqlConnection |
| 5550: | * @static |
| 5551: | */ |
| 5552: | public static function setSchemaGrammar($grammar) |
| 5553: | { //Method inherited from \Illuminate\Database\Connection |
| 5554: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5555: | return $instance->setSchemaGrammar($grammar); |
| 5556: | } |
| 5557: | /** |
| 5558: | * Get the query post processor used by the connection. |
| 5559: | * |
| 5560: | * @return \Illuminate\Database\Query\Processors\Processor |
| 5561: | * @static |
| 5562: | */ |
| 5563: | public static function getPostProcessor() |
| 5564: | { //Method inherited from \Illuminate\Database\Connection |
| 5565: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5566: | return $instance->getPostProcessor(); |
| 5567: | } |
| 5568: | /** |
| 5569: | * Set the query post processor used by the connection. |
| 5570: | * |
| 5571: | * @param \Illuminate\Database\Query\Processors\Processor $processor |
| 5572: | * @return \Illuminate\Database\MySqlConnection |
| 5573: | * @static |
| 5574: | */ |
| 5575: | public static function setPostProcessor($processor) |
| 5576: | { //Method inherited from \Illuminate\Database\Connection |
| 5577: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5578: | return $instance->setPostProcessor($processor); |
| 5579: | } |
| 5580: | /** |
| 5581: | * Get the event dispatcher used by the connection. |
| 5582: | * |
| 5583: | * @return \Illuminate\Contracts\Events\Dispatcher |
| 5584: | * @static |
| 5585: | */ |
| 5586: | public static function getEventDispatcher() |
| 5587: | { //Method inherited from \Illuminate\Database\Connection |
| 5588: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5589: | return $instance->getEventDispatcher(); |
| 5590: | } |
| 5591: | /** |
| 5592: | * Set the event dispatcher instance on the connection. |
| 5593: | * |
| 5594: | * @param \Illuminate\Contracts\Events\Dispatcher $events |
| 5595: | * @return \Illuminate\Database\MySqlConnection |
| 5596: | * @static |
| 5597: | */ |
| 5598: | public static function setEventDispatcher($events) |
| 5599: | { //Method inherited from \Illuminate\Database\Connection |
| 5600: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5601: | return $instance->setEventDispatcher($events); |
| 5602: | } |
| 5603: | /** |
| 5604: | * Unset the event dispatcher for this connection. |
| 5605: | * |
| 5606: | * @return void |
| 5607: | * @static |
| 5608: | */ |
| 5609: | public static function unsetEventDispatcher() |
| 5610: | { //Method inherited from \Illuminate\Database\Connection |
| 5611: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5612: | $instance->unsetEventDispatcher(); |
| 5613: | } |
| 5614: | /** |
| 5615: | * Set the transaction manager instance on the connection. |
| 5616: | * |
| 5617: | * @param \Illuminate\Database\DatabaseTransactionsManager $manager |
| 5618: | * @return \Illuminate\Database\MySqlConnection |
| 5619: | * @static |
| 5620: | */ |
| 5621: | public static function setTransactionManager($manager) |
| 5622: | { //Method inherited from \Illuminate\Database\Connection |
| 5623: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5624: | return $instance->setTransactionManager($manager); |
| 5625: | } |
| 5626: | /** |
| 5627: | * Unset the transaction manager for this connection. |
| 5628: | * |
| 5629: | * @return void |
| 5630: | * @static |
| 5631: | */ |
| 5632: | public static function unsetTransactionManager() |
| 5633: | { //Method inherited from \Illuminate\Database\Connection |
| 5634: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5635: | $instance->unsetTransactionManager(); |
| 5636: | } |
| 5637: | /** |
| 5638: | * Determine if the connection is in a "dry run". |
| 5639: | * |
| 5640: | * @return bool |
| 5641: | * @static |
| 5642: | */ |
| 5643: | public static function pretending() |
| 5644: | { //Method inherited from \Illuminate\Database\Connection |
| 5645: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5646: | return $instance->pretending(); |
| 5647: | } |
| 5648: | /** |
| 5649: | * Get the connection query log. |
| 5650: | * |
| 5651: | * @return array |
| 5652: | * @static |
| 5653: | */ |
| 5654: | public static function getQueryLog() |
| 5655: | { //Method inherited from \Illuminate\Database\Connection |
| 5656: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5657: | return $instance->getQueryLog(); |
| 5658: | } |
| 5659: | /** |
| 5660: | * Clear the query log. |
| 5661: | * |
| 5662: | * @return void |
| 5663: | * @static |
| 5664: | */ |
| 5665: | public static function flushQueryLog() |
| 5666: | { //Method inherited from \Illuminate\Database\Connection |
| 5667: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5668: | $instance->flushQueryLog(); |
| 5669: | } |
| 5670: | /** |
| 5671: | * Enable the query log on the connection. |
| 5672: | * |
| 5673: | * @return void |
| 5674: | * @static |
| 5675: | */ |
| 5676: | public static function enableQueryLog() |
| 5677: | { //Method inherited from \Illuminate\Database\Connection |
| 5678: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5679: | $instance->enableQueryLog(); |
| 5680: | } |
| 5681: | /** |
| 5682: | * Disable the query log on the connection. |
| 5683: | * |
| 5684: | * @return void |
| 5685: | * @static |
| 5686: | */ |
| 5687: | public static function disableQueryLog() |
| 5688: | { //Method inherited from \Illuminate\Database\Connection |
| 5689: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5690: | $instance->disableQueryLog(); |
| 5691: | } |
| 5692: | /** |
| 5693: | * Determine whether we're logging queries. |
| 5694: | * |
| 5695: | * @return bool |
| 5696: | * @static |
| 5697: | */ |
| 5698: | public static function logging() |
| 5699: | { //Method inherited from \Illuminate\Database\Connection |
| 5700: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5701: | return $instance->logging(); |
| 5702: | } |
| 5703: | /** |
| 5704: | * Get the name of the connected database. |
| 5705: | * |
| 5706: | * @return string |
| 5707: | * @static |
| 5708: | */ |
| 5709: | public static function getDatabaseName() |
| 5710: | { //Method inherited from \Illuminate\Database\Connection |
| 5711: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5712: | return $instance->getDatabaseName(); |
| 5713: | } |
| 5714: | /** |
| 5715: | * Set the name of the connected database. |
| 5716: | * |
| 5717: | * @param string $database |
| 5718: | * @return \Illuminate\Database\MySqlConnection |
| 5719: | * @static |
| 5720: | */ |
| 5721: | public static function setDatabaseName($database) |
| 5722: | { //Method inherited from \Illuminate\Database\Connection |
| 5723: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5724: | return $instance->setDatabaseName($database); |
| 5725: | } |
| 5726: | /** |
| 5727: | * Set the read / write type of the connection. |
| 5728: | * |
| 5729: | * @param string|null $readWriteType |
| 5730: | * @return \Illuminate\Database\MySqlConnection |
| 5731: | * @static |
| 5732: | */ |
| 5733: | public static function setReadWriteType($readWriteType) |
| 5734: | { //Method inherited from \Illuminate\Database\Connection |
| 5735: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5736: | return $instance->setReadWriteType($readWriteType); |
| 5737: | } |
| 5738: | /** |
| 5739: | * Get the table prefix for the connection. |
| 5740: | * |
| 5741: | * @return string |
| 5742: | * @static |
| 5743: | */ |
| 5744: | public static function getTablePrefix() |
| 5745: | { //Method inherited from \Illuminate\Database\Connection |
| 5746: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5747: | return $instance->getTablePrefix(); |
| 5748: | } |
| 5749: | /** |
| 5750: | * Set the table prefix in use by the connection. |
| 5751: | * |
| 5752: | * @param string $prefix |
| 5753: | * @return \Illuminate\Database\MySqlConnection |
| 5754: | * @static |
| 5755: | */ |
| 5756: | public static function setTablePrefix($prefix) |
| 5757: | { //Method inherited from \Illuminate\Database\Connection |
| 5758: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5759: | return $instance->setTablePrefix($prefix); |
| 5760: | } |
| 5761: | /** |
| 5762: | * Set the table prefix and return the grammar. |
| 5763: | * |
| 5764: | * @param \Illuminate\Database\Grammar $grammar |
| 5765: | * @return \Illuminate\Database\Grammar |
| 5766: | * @static |
| 5767: | */ |
| 5768: | public static function withTablePrefix($grammar) |
| 5769: | { //Method inherited from \Illuminate\Database\Connection |
| 5770: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5771: | return $instance->withTablePrefix($grammar); |
| 5772: | } |
| 5773: | /** |
| 5774: | * Register a connection resolver. |
| 5775: | * |
| 5776: | * @param string $driver |
| 5777: | * @param \Closure $callback |
| 5778: | * @return void |
| 5779: | * @static |
| 5780: | */ |
| 5781: | public static function resolverFor($driver, $callback) |
| 5782: | { //Method inherited from \Illuminate\Database\Connection |
| 5783: | \Illuminate\Database\MySqlConnection::resolverFor($driver, $callback); |
| 5784: | } |
| 5785: | /** |
| 5786: | * Get the connection resolver for the given driver. |
| 5787: | * |
| 5788: | * @param string $driver |
| 5789: | * @return mixed |
| 5790: | * @static |
| 5791: | */ |
| 5792: | public static function getResolver($driver) |
| 5793: | { //Method inherited from \Illuminate\Database\Connection |
| 5794: | return \Illuminate\Database\MySqlConnection::getResolver($driver); |
| 5795: | } |
| 5796: | /** |
| 5797: | * Execute a Closure within a transaction. |
| 5798: | * |
| 5799: | * @param \Closure $callback |
| 5800: | * @param int $attempts |
| 5801: | * @return mixed |
| 5802: | * @throws \Throwable |
| 5803: | * @static |
| 5804: | */ |
| 5805: | public static function transaction($callback, $attempts = 1) |
| 5806: | { //Method inherited from \Illuminate\Database\Connection |
| 5807: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5808: | return $instance->transaction($callback, $attempts); |
| 5809: | } |
| 5810: | /** |
| 5811: | * Start a new database transaction. |
| 5812: | * |
| 5813: | * @return void |
| 5814: | * @throws \Throwable |
| 5815: | * @static |
| 5816: | */ |
| 5817: | public static function beginTransaction() |
| 5818: | { //Method inherited from \Illuminate\Database\Connection |
| 5819: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5820: | $instance->beginTransaction(); |
| 5821: | } |
| 5822: | /** |
| 5823: | * Commit the active database transaction. |
| 5824: | * |
| 5825: | * @return void |
| 5826: | * @throws \Throwable |
| 5827: | * @static |
| 5828: | */ |
| 5829: | public static function commit() |
| 5830: | { //Method inherited from \Illuminate\Database\Connection |
| 5831: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5832: | $instance->commit(); |
| 5833: | } |
| 5834: | /** |
| 5835: | * Rollback the active database transaction. |
| 5836: | * |
| 5837: | * @param int|null $toLevel |
| 5838: | * @return void |
| 5839: | * @throws \Throwable |
| 5840: | * @static |
| 5841: | */ |
| 5842: | public static function rollBack($toLevel = null) |
| 5843: | { //Method inherited from \Illuminate\Database\Connection |
| 5844: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5845: | $instance->rollBack($toLevel); |
| 5846: | } |
| 5847: | /** |
| 5848: | * Get the number of active transactions. |
| 5849: | * |
| 5850: | * @return int |
| 5851: | * @static |
| 5852: | */ |
| 5853: | public static function transactionLevel() |
| 5854: | { //Method inherited from \Illuminate\Database\Connection |
| 5855: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5856: | return $instance->transactionLevel(); |
| 5857: | } |
| 5858: | /** |
| 5859: | * Execute the callback after a transaction commits. |
| 5860: | * |
| 5861: | * @param callable $callback |
| 5862: | * @return void |
| 5863: | * @throws \RuntimeException |
| 5864: | * @static |
| 5865: | */ |
| 5866: | public static function afterCommit($callback) |
| 5867: | { //Method inherited from \Illuminate\Database\Connection |
| 5868: | /** @var \Illuminate\Database\MySqlConnection $instance */ |
| 5869: | $instance->afterCommit($callback); |
| 5870: | } |
| 5871: | |
| 5872: | } |
| 5873: | /** |
| 5874: | * |
| 5875: | * |
| 5876: | * @see \Illuminate\Events\Dispatcher |
| 5877: | */ |
| 5878: | class Event { |
| 5879: | /** |
| 5880: | * Register an event listener with the dispatcher. |
| 5881: | * |
| 5882: | * @param \Closure|string|array $events |
| 5883: | * @param \Closure|string|array|null $listener |
| 5884: | * @return void |
| 5885: | * @static |
| 5886: | */ |
| 5887: | public static function listen($events, $listener = null) |
| 5888: | { |
| 5889: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 5890: | $instance->listen($events, $listener); |
| 5891: | } |
| 5892: | /** |
| 5893: | * Determine if a given event has listeners. |
| 5894: | * |
| 5895: | * @param string $eventName |
| 5896: | * @return bool |
| 5897: | * @static |
| 5898: | */ |
| 5899: | public static function hasListeners($eventName) |
| 5900: | { |
| 5901: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 5902: | return $instance->hasListeners($eventName); |
| 5903: | } |
| 5904: | /** |
| 5905: | * Determine if the given event has any wildcard listeners. |
| 5906: | * |
| 5907: | * @param string $eventName |
| 5908: | * @return bool |
| 5909: | * @static |
| 5910: | */ |
| 5911: | public static function hasWildcardListeners($eventName) |
| 5912: | { |
| 5913: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 5914: | return $instance->hasWildcardListeners($eventName); |
| 5915: | } |
| 5916: | /** |
| 5917: | * Register an event and payload to be fired later. |
| 5918: | * |
| 5919: | * @param string $event |
| 5920: | * @param object|array $payload |
| 5921: | * @return void |
| 5922: | * @static |
| 5923: | */ |
| 5924: | public static function push($event, $payload = []) |
| 5925: | { |
| 5926: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 5927: | $instance->push($event, $payload); |
| 5928: | } |
| 5929: | /** |
| 5930: | * Flush a set of pushed events. |
| 5931: | * |
| 5932: | * @param string $event |
| 5933: | * @return void |
| 5934: | * @static |
| 5935: | */ |
| 5936: | public static function flush($event) |
| 5937: | { |
| 5938: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 5939: | $instance->flush($event); |
| 5940: | } |
| 5941: | /** |
| 5942: | * Register an event subscriber with the dispatcher. |
| 5943: | * |
| 5944: | * @param object|string $subscriber |
| 5945: | * @return void |
| 5946: | * @static |
| 5947: | */ |
| 5948: | public static function subscribe($subscriber) |
| 5949: | { |
| 5950: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 5951: | $instance->subscribe($subscriber); |
| 5952: | } |
| 5953: | /** |
| 5954: | * Fire an event until the first non-null response is returned. |
| 5955: | * |
| 5956: | * @param string|object $event |
| 5957: | * @param mixed $payload |
| 5958: | * @return array|null |
| 5959: | * @static |
| 5960: | */ |
| 5961: | public static function until($event, $payload = []) |
| 5962: | { |
| 5963: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 5964: | return $instance->until($event, $payload); |
| 5965: | } |
| 5966: | /** |
| 5967: | * Fire an event and call the listeners. |
| 5968: | * |
| 5969: | * @param string|object $event |
| 5970: | * @param mixed $payload |
| 5971: | * @param bool $halt |
| 5972: | * @return array|null |
| 5973: | * @static |
| 5974: | */ |
| 5975: | public static function dispatch($event, $payload = [], $halt = false) |
| 5976: | { |
| 5977: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 5978: | return $instance->dispatch($event, $payload, $halt); |
| 5979: | } |
| 5980: | /** |
| 5981: | * Get all of the listeners for a given event name. |
| 5982: | * |
| 5983: | * @param string $eventName |
| 5984: | * @return array |
| 5985: | * @static |
| 5986: | */ |
| 5987: | public static function getListeners($eventName) |
| 5988: | { |
| 5989: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 5990: | return $instance->getListeners($eventName); |
| 5991: | } |
| 5992: | /** |
| 5993: | * Register an event listener with the dispatcher. |
| 5994: | * |
| 5995: | * @param \Closure|string|array $listener |
| 5996: | * @param bool $wildcard |
| 5997: | * @return \Closure |
| 5998: | * @static |
| 5999: | */ |
| 6000: | public static function makeListener($listener, $wildcard = false) |
| 6001: | { |
| 6002: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 6003: | return $instance->makeListener($listener, $wildcard); |
| 6004: | } |
| 6005: | /** |
| 6006: | * Create a class based listener using the IoC container. |
| 6007: | * |
| 6008: | * @param string $listener |
| 6009: | * @param bool $wildcard |
| 6010: | * @return \Closure |
| 6011: | * @static |
| 6012: | */ |
| 6013: | public static function createClassListener($listener, $wildcard = false) |
| 6014: | { |
| 6015: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 6016: | return $instance->createClassListener($listener, $wildcard); |
| 6017: | } |
| 6018: | /** |
| 6019: | * Remove a set of listeners from the dispatcher. |
| 6020: | * |
| 6021: | * @param string $event |
| 6022: | * @return void |
| 6023: | * @static |
| 6024: | */ |
| 6025: | public static function forget($event) |
| 6026: | { |
| 6027: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 6028: | $instance->forget($event); |
| 6029: | } |
| 6030: | /** |
| 6031: | * Forget all of the pushed listeners. |
| 6032: | * |
| 6033: | * @return void |
| 6034: | * @static |
| 6035: | */ |
| 6036: | public static function forgetPushed() |
| 6037: | { |
| 6038: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 6039: | $instance->forgetPushed(); |
| 6040: | } |
| 6041: | /** |
| 6042: | * Set the queue resolver implementation. |
| 6043: | * |
| 6044: | * @param callable $resolver |
| 6045: | * @return \Illuminate\Events\Dispatcher |
| 6046: | * @static |
| 6047: | */ |
| 6048: | public static function setQueueResolver($resolver) |
| 6049: | { |
| 6050: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 6051: | return $instance->setQueueResolver($resolver); |
| 6052: | } |
| 6053: | /** |
| 6054: | * Gets the raw, unprepared listeners. |
| 6055: | * |
| 6056: | * @return array |
| 6057: | * @static |
| 6058: | */ |
| 6059: | public static function getRawListeners() |
| 6060: | { |
| 6061: | /** @var \Illuminate\Events\Dispatcher $instance */ |
| 6062: | return $instance->getRawListeners(); |
| 6063: | } |
| 6064: | /** |
| 6065: | * Register a custom macro. |
| 6066: | * |
| 6067: | * @param string $name |
| 6068: | * @param object|callable $macro |
| 6069: | * @return void |
| 6070: | * @static |
| 6071: | */ |
| 6072: | public static function macro($name, $macro) |
| 6073: | { |
| 6074: | \Illuminate\Events\Dispatcher::macro($name, $macro); |
| 6075: | } |
| 6076: | /** |
| 6077: | * Mix another object into the class. |
| 6078: | * |
| 6079: | * @param object $mixin |
| 6080: | * @param bool $replace |
| 6081: | * @return void |
| 6082: | * @throws \ReflectionException |
| 6083: | * @static |
| 6084: | */ |
| 6085: | public static function mixin($mixin, $replace = true) |
| 6086: | { |
| 6087: | \Illuminate\Events\Dispatcher::mixin($mixin, $replace); |
| 6088: | } |
| 6089: | /** |
| 6090: | * Checks if macro is registered. |
| 6091: | * |
| 6092: | * @param string $name |
| 6093: | * @return bool |
| 6094: | * @static |
| 6095: | */ |
| 6096: | public static function hasMacro($name) |
| 6097: | { |
| 6098: | return \Illuminate\Events\Dispatcher::hasMacro($name); |
| 6099: | } |
| 6100: | /** |
| 6101: | * Flush the existing macros. |
| 6102: | * |
| 6103: | * @return void |
| 6104: | * @static |
| 6105: | */ |
| 6106: | public static function flushMacros() |
| 6107: | { |
| 6108: | \Illuminate\Events\Dispatcher::flushMacros(); |
| 6109: | } |
| 6110: | /** |
| 6111: | * Assert if an event has a listener attached to it. |
| 6112: | * |
| 6113: | * @param string $expectedEvent |
| 6114: | * @param string|array $expectedListener |
| 6115: | * @return void |
| 6116: | * @static |
| 6117: | */ |
| 6118: | public static function assertListening($expectedEvent, $expectedListener) |
| 6119: | { |
| 6120: | /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */ |
| 6121: | $instance->assertListening($expectedEvent, $expectedListener); |
| 6122: | } |
| 6123: | /** |
| 6124: | * Assert if an event was dispatched based on a truth-test callback. |
| 6125: | * |
| 6126: | * @param string|\Closure $event |
| 6127: | * @param callable|int|null $callback |
| 6128: | * @return void |
| 6129: | * @static |
| 6130: | */ |
| 6131: | public static function assertDispatched($event, $callback = null) |
| 6132: | { |
| 6133: | /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */ |
| 6134: | $instance->assertDispatched($event, $callback); |
| 6135: | } |
| 6136: | /** |
| 6137: | * Assert if an event was dispatched a number of times. |
| 6138: | * |
| 6139: | * @param string $event |
| 6140: | * @param int $times |
| 6141: | * @return void |
| 6142: | * @static |
| 6143: | */ |
| 6144: | public static function assertDispatchedTimes($event, $times = 1) |
| 6145: | { |
| 6146: | /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */ |
| 6147: | $instance->assertDispatchedTimes($event, $times); |
| 6148: | } |
| 6149: | /** |
| 6150: | * Determine if an event was dispatched based on a truth-test callback. |
| 6151: | * |
| 6152: | * @param string|\Closure $event |
| 6153: | * @param callable|null $callback |
| 6154: | * @return void |
| 6155: | * @static |
| 6156: | */ |
| 6157: | public static function assertNotDispatched($event, $callback = null) |
| 6158: | { |
| 6159: | /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */ |
| 6160: | $instance->assertNotDispatched($event, $callback); |
| 6161: | } |
| 6162: | /** |
| 6163: | * Assert that no events were dispatched. |
| 6164: | * |
| 6165: | * @return void |
| 6166: | * @static |
| 6167: | */ |
| 6168: | public static function assertNothingDispatched() |
| 6169: | { |
| 6170: | /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */ |
| 6171: | $instance->assertNothingDispatched(); |
| 6172: | } |
| 6173: | /** |
| 6174: | * Get all of the events matching a truth-test callback. |
| 6175: | * |
| 6176: | * @param string $event |
| 6177: | * @param callable|null $callback |
| 6178: | * @return \Illuminate\Support\Collection |
| 6179: | * @static |
| 6180: | */ |
| 6181: | public static function dispatched($event, $callback = null) |
| 6182: | { |
| 6183: | /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */ |
| 6184: | return $instance->dispatched($event, $callback); |
| 6185: | } |
| 6186: | /** |
| 6187: | * Determine if the given event has been dispatched. |
| 6188: | * |
| 6189: | * @param string $event |
| 6190: | * @return bool |
| 6191: | * @static |
| 6192: | */ |
| 6193: | public static function hasDispatched($event) |
| 6194: | { |
| 6195: | /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */ |
| 6196: | return $instance->hasDispatched($event); |
| 6197: | } |
| 6198: | |
| 6199: | } |
| 6200: | /** |
| 6201: | * |
| 6202: | * |
| 6203: | * @see \Illuminate\Filesystem\Filesystem |
| 6204: | */ |
| 6205: | class File { |
| 6206: | /** |
| 6207: | * Determine if a file or directory exists. |
| 6208: | * |
| 6209: | * @param string $path |
| 6210: | * @return bool |
| 6211: | * @static |
| 6212: | */ |
| 6213: | public static function exists($path) |
| 6214: | { |
| 6215: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6216: | return $instance->exists($path); |
| 6217: | } |
| 6218: | /** |
| 6219: | * Determine if a file or directory is missing. |
| 6220: | * |
| 6221: | * @param string $path |
| 6222: | * @return bool |
| 6223: | * @static |
| 6224: | */ |
| 6225: | public static function missing($path) |
| 6226: | { |
| 6227: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6228: | return $instance->missing($path); |
| 6229: | } |
| 6230: | /** |
| 6231: | * Get the contents of a file. |
| 6232: | * |
| 6233: | * @param string $path |
| 6234: | * @param bool $lock |
| 6235: | * @return string |
| 6236: | * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException |
| 6237: | * @static |
| 6238: | */ |
| 6239: | public static function get($path, $lock = false) |
| 6240: | { |
| 6241: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6242: | return $instance->get($path, $lock); |
| 6243: | } |
| 6244: | /** |
| 6245: | * Get contents of a file with shared access. |
| 6246: | * |
| 6247: | * @param string $path |
| 6248: | * @return string |
| 6249: | * @static |
| 6250: | */ |
| 6251: | public static function sharedGet($path) |
| 6252: | { |
| 6253: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6254: | return $instance->sharedGet($path); |
| 6255: | } |
| 6256: | /** |
| 6257: | * Get the returned value of a file. |
| 6258: | * |
| 6259: | * @param string $path |
| 6260: | * @param array $data |
| 6261: | * @return mixed |
| 6262: | * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException |
| 6263: | * @static |
| 6264: | */ |
| 6265: | public static function getRequire($path, $data = []) |
| 6266: | { |
| 6267: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6268: | return $instance->getRequire($path, $data); |
| 6269: | } |
| 6270: | /** |
| 6271: | * Require the given file once. |
| 6272: | * |
| 6273: | * @param string $path |
| 6274: | * @param array $data |
| 6275: | * @return mixed |
| 6276: | * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException |
| 6277: | * @static |
| 6278: | */ |
| 6279: | public static function requireOnce($path, $data = []) |
| 6280: | { |
| 6281: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6282: | return $instance->requireOnce($path, $data); |
| 6283: | } |
| 6284: | /** |
| 6285: | * Get the contents of a file one line at a time. |
| 6286: | * |
| 6287: | * @param string $path |
| 6288: | * @return \Illuminate\Support\LazyCollection |
| 6289: | * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException |
| 6290: | * @static |
| 6291: | */ |
| 6292: | public static function lines($path) |
| 6293: | { |
| 6294: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6295: | return $instance->lines($path); |
| 6296: | } |
| 6297: | /** |
| 6298: | * Get the MD5 hash of the file at the given path. |
| 6299: | * |
| 6300: | * @param string $path |
| 6301: | * @return string |
| 6302: | * @static |
| 6303: | */ |
| 6304: | public static function hash($path) |
| 6305: | { |
| 6306: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6307: | return $instance->hash($path); |
| 6308: | } |
| 6309: | /** |
| 6310: | * Write the contents of a file. |
| 6311: | * |
| 6312: | * @param string $path |
| 6313: | * @param string $contents |
| 6314: | * @param bool $lock |
| 6315: | * @return int|bool |
| 6316: | * @static |
| 6317: | */ |
| 6318: | public static function put($path, $contents, $lock = false) |
| 6319: | { |
| 6320: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6321: | return $instance->put($path, $contents, $lock); |
| 6322: | } |
| 6323: | /** |
| 6324: | * Write the contents of a file, replacing it atomically if it already exists. |
| 6325: | * |
| 6326: | * @param string $path |
| 6327: | * @param string $content |
| 6328: | * @return void |
| 6329: | * @static |
| 6330: | */ |
| 6331: | public static function replace($path, $content) |
| 6332: | { |
| 6333: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6334: | $instance->replace($path, $content); |
| 6335: | } |
| 6336: | /** |
| 6337: | * Replace a given string within a given file. |
| 6338: | * |
| 6339: | * @param array|string $search |
| 6340: | * @param array|string $replace |
| 6341: | * @param string $path |
| 6342: | * @return void |
| 6343: | * @static |
| 6344: | */ |
| 6345: | public static function replaceInFile($search, $replace, $path) |
| 6346: | { |
| 6347: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6348: | $instance->replaceInFile($search, $replace, $path); |
| 6349: | } |
| 6350: | /** |
| 6351: | * Prepend to a file. |
| 6352: | * |
| 6353: | * @param string $path |
| 6354: | * @param string $data |
| 6355: | * @return int |
| 6356: | * @static |
| 6357: | */ |
| 6358: | public static function prepend($path, $data) |
| 6359: | { |
| 6360: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6361: | return $instance->prepend($path, $data); |
| 6362: | } |
| 6363: | /** |
| 6364: | * Append to a file. |
| 6365: | * |
| 6366: | * @param string $path |
| 6367: | * @param string $data |
| 6368: | * @return int |
| 6369: | * @static |
| 6370: | */ |
| 6371: | public static function append($path, $data) |
| 6372: | { |
| 6373: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6374: | return $instance->append($path, $data); |
| 6375: | } |
| 6376: | /** |
| 6377: | * Get or set UNIX mode of a file or directory. |
| 6378: | * |
| 6379: | * @param string $path |
| 6380: | * @param int|null $mode |
| 6381: | * @return mixed |
| 6382: | * @static |
| 6383: | */ |
| 6384: | public static function chmod($path, $mode = null) |
| 6385: | { |
| 6386: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6387: | return $instance->chmod($path, $mode); |
| 6388: | } |
| 6389: | /** |
| 6390: | * Delete the file at a given path. |
| 6391: | * |
| 6392: | * @param string|array $paths |
| 6393: | * @return bool |
| 6394: | * @static |
| 6395: | */ |
| 6396: | public static function delete($paths) |
| 6397: | { |
| 6398: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6399: | return $instance->delete($paths); |
| 6400: | } |
| 6401: | /** |
| 6402: | * Move a file to a new location. |
| 6403: | * |
| 6404: | * @param string $path |
| 6405: | * @param string $target |
| 6406: | * @return bool |
| 6407: | * @static |
| 6408: | */ |
| 6409: | public static function move($path, $target) |
| 6410: | { |
| 6411: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6412: | return $instance->move($path, $target); |
| 6413: | } |
| 6414: | /** |
| 6415: | * Copy a file to a new location. |
| 6416: | * |
| 6417: | * @param string $path |
| 6418: | * @param string $target |
| 6419: | * @return bool |
| 6420: | * @static |
| 6421: | */ |
| 6422: | public static function copy($path, $target) |
| 6423: | { |
| 6424: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6425: | return $instance->copy($path, $target); |
| 6426: | } |
| 6427: | /** |
| 6428: | * Create a symlink to the target file or directory. On Windows, a hard link is created if the target is a file. |
| 6429: | * |
| 6430: | * @param string $target |
| 6431: | * @param string $link |
| 6432: | * @return void |
| 6433: | * @static |
| 6434: | */ |
| 6435: | public static function link($target, $link) |
| 6436: | { |
| 6437: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6438: | $instance->link($target, $link); |
| 6439: | } |
| 6440: | /** |
| 6441: | * Create a relative symlink to the target file or directory. |
| 6442: | * |
| 6443: | * @param string $target |
| 6444: | * @param string $link |
| 6445: | * @return void |
| 6446: | * @throws \RuntimeException |
| 6447: | * @static |
| 6448: | */ |
| 6449: | public static function relativeLink($target, $link) |
| 6450: | { |
| 6451: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6452: | $instance->relativeLink($target, $link); |
| 6453: | } |
| 6454: | /** |
| 6455: | * Extract the file name from a file path. |
| 6456: | * |
| 6457: | * @param string $path |
| 6458: | * @return string |
| 6459: | * @static |
| 6460: | */ |
| 6461: | public static function name($path) |
| 6462: | { |
| 6463: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6464: | return $instance->name($path); |
| 6465: | } |
| 6466: | /** |
| 6467: | * Extract the trailing name component from a file path. |
| 6468: | * |
| 6469: | * @param string $path |
| 6470: | * @return string |
| 6471: | * @static |
| 6472: | */ |
| 6473: | public static function basename($path) |
| 6474: | { |
| 6475: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6476: | return $instance->basename($path); |
| 6477: | } |
| 6478: | /** |
| 6479: | * Extract the parent directory from a file path. |
| 6480: | * |
| 6481: | * @param string $path |
| 6482: | * @return string |
| 6483: | * @static |
| 6484: | */ |
| 6485: | public static function dirname($path) |
| 6486: | { |
| 6487: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6488: | return $instance->dirname($path); |
| 6489: | } |
| 6490: | /** |
| 6491: | * Extract the file extension from a file path. |
| 6492: | * |
| 6493: | * @param string $path |
| 6494: | * @return string |
| 6495: | * @static |
| 6496: | */ |
| 6497: | public static function extension($path) |
| 6498: | { |
| 6499: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6500: | return $instance->extension($path); |
| 6501: | } |
| 6502: | /** |
| 6503: | * Guess the file extension from the mime-type of a given file. |
| 6504: | * |
| 6505: | * @param string $path |
| 6506: | * @return string|null |
| 6507: | * @throws \RuntimeException |
| 6508: | * @static |
| 6509: | */ |
| 6510: | public static function guessExtension($path) |
| 6511: | { |
| 6512: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6513: | return $instance->guessExtension($path); |
| 6514: | } |
| 6515: | /** |
| 6516: | * Get the file type of a given file. |
| 6517: | * |
| 6518: | * @param string $path |
| 6519: | * @return string |
| 6520: | * @static |
| 6521: | */ |
| 6522: | public static function type($path) |
| 6523: | { |
| 6524: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6525: | return $instance->type($path); |
| 6526: | } |
| 6527: | /** |
| 6528: | * Get the mime-type of a given file. |
| 6529: | * |
| 6530: | * @param string $path |
| 6531: | * @return string|false |
| 6532: | * @static |
| 6533: | */ |
| 6534: | public static function mimeType($path) |
| 6535: | { |
| 6536: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6537: | return $instance->mimeType($path); |
| 6538: | } |
| 6539: | /** |
| 6540: | * Get the file size of a given file. |
| 6541: | * |
| 6542: | * @param string $path |
| 6543: | * @return int |
| 6544: | * @static |
| 6545: | */ |
| 6546: | public static function size($path) |
| 6547: | { |
| 6548: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6549: | return $instance->size($path); |
| 6550: | } |
| 6551: | /** |
| 6552: | * Get the file's last modification time. |
| 6553: | * |
| 6554: | * @param string $path |
| 6555: | * @return int |
| 6556: | * @static |
| 6557: | */ |
| 6558: | public static function lastModified($path) |
| 6559: | { |
| 6560: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6561: | return $instance->lastModified($path); |
| 6562: | } |
| 6563: | /** |
| 6564: | * Determine if the given path is a directory. |
| 6565: | * |
| 6566: | * @param string $directory |
| 6567: | * @return bool |
| 6568: | * @static |
| 6569: | */ |
| 6570: | public static function isDirectory($directory) |
| 6571: | { |
| 6572: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6573: | return $instance->isDirectory($directory); |
| 6574: | } |
| 6575: | /** |
| 6576: | * Determine if the given path is a directory that does not contain any other files or directories. |
| 6577: | * |
| 6578: | * @param string $directory |
| 6579: | * @param bool $ignoreDotFiles |
| 6580: | * @return bool |
| 6581: | * @static |
| 6582: | */ |
| 6583: | public static function isEmptyDirectory($directory, $ignoreDotFiles = false) |
| 6584: | { |
| 6585: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6586: | return $instance->isEmptyDirectory($directory, $ignoreDotFiles); |
| 6587: | } |
| 6588: | /** |
| 6589: | * Determine if the given path is readable. |
| 6590: | * |
| 6591: | * @param string $path |
| 6592: | * @return bool |
| 6593: | * @static |
| 6594: | */ |
| 6595: | public static function isReadable($path) |
| 6596: | { |
| 6597: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6598: | return $instance->isReadable($path); |
| 6599: | } |
| 6600: | /** |
| 6601: | * Determine if the given path is writable. |
| 6602: | * |
| 6603: | * @param string $path |
| 6604: | * @return bool |
| 6605: | * @static |
| 6606: | */ |
| 6607: | public static function isWritable($path) |
| 6608: | { |
| 6609: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6610: | return $instance->isWritable($path); |
| 6611: | } |
| 6612: | /** |
| 6613: | * Determine if two files are the same by comparing their hashes. |
| 6614: | * |
| 6615: | * @param string $firstFile |
| 6616: | * @param string $secondFile |
| 6617: | * @return bool |
| 6618: | * @static |
| 6619: | */ |
| 6620: | public static function hasSameHash($firstFile, $secondFile) |
| 6621: | { |
| 6622: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6623: | return $instance->hasSameHash($firstFile, $secondFile); |
| 6624: | } |
| 6625: | /** |
| 6626: | * Determine if the given path is a file. |
| 6627: | * |
| 6628: | * @param string $file |
| 6629: | * @return bool |
| 6630: | * @static |
| 6631: | */ |
| 6632: | public static function isFile($file) |
| 6633: | { |
| 6634: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6635: | return $instance->isFile($file); |
| 6636: | } |
| 6637: | /** |
| 6638: | * Find path names matching a given pattern. |
| 6639: | * |
| 6640: | * @param string $pattern |
| 6641: | * @param int $flags |
| 6642: | * @return array |
| 6643: | * @static |
| 6644: | */ |
| 6645: | public static function glob($pattern, $flags = 0) |
| 6646: | { |
| 6647: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6648: | return $instance->glob($pattern, $flags); |
| 6649: | } |
| 6650: | /** |
| 6651: | * Get an array of all files in a directory. |
| 6652: | * |
| 6653: | * @param string $directory |
| 6654: | * @param bool $hidden |
| 6655: | * @return \Symfony\Component\Finder\SplFileInfo[] |
| 6656: | * @static |
| 6657: | */ |
| 6658: | public static function files($directory, $hidden = false) |
| 6659: | { |
| 6660: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6661: | return $instance->files($directory, $hidden); |
| 6662: | } |
| 6663: | /** |
| 6664: | * Get all of the files from the given directory (recursive). |
| 6665: | * |
| 6666: | * @param string $directory |
| 6667: | * @param bool $hidden |
| 6668: | * @return \Symfony\Component\Finder\SplFileInfo[] |
| 6669: | * @static |
| 6670: | */ |
| 6671: | public static function allFiles($directory, $hidden = false) |
| 6672: | { |
| 6673: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6674: | return $instance->allFiles($directory, $hidden); |
| 6675: | } |
| 6676: | /** |
| 6677: | * Get all of the directories within a given directory. |
| 6678: | * |
| 6679: | * @param string $directory |
| 6680: | * @return array |
| 6681: | * @static |
| 6682: | */ |
| 6683: | public static function directories($directory) |
| 6684: | { |
| 6685: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6686: | return $instance->directories($directory); |
| 6687: | } |
| 6688: | /** |
| 6689: | * Ensure a directory exists. |
| 6690: | * |
| 6691: | * @param string $path |
| 6692: | * @param int $mode |
| 6693: | * @param bool $recursive |
| 6694: | * @return void |
| 6695: | * @static |
| 6696: | */ |
| 6697: | public static function ensureDirectoryExists($path, $mode = 493, $recursive = true) |
| 6698: | { |
| 6699: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6700: | $instance->ensureDirectoryExists($path, $mode, $recursive); |
| 6701: | } |
| 6702: | /** |
| 6703: | * Create a directory. |
| 6704: | * |
| 6705: | * @param string $path |
| 6706: | * @param int $mode |
| 6707: | * @param bool $recursive |
| 6708: | * @param bool $force |
| 6709: | * @return bool |
| 6710: | * @static |
| 6711: | */ |
| 6712: | public static function makeDirectory($path, $mode = 493, $recursive = false, $force = false) |
| 6713: | { |
| 6714: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6715: | return $instance->makeDirectory($path, $mode, $recursive, $force); |
| 6716: | } |
| 6717: | /** |
| 6718: | * Move a directory. |
| 6719: | * |
| 6720: | * @param string $from |
| 6721: | * @param string $to |
| 6722: | * @param bool $overwrite |
| 6723: | * @return bool |
| 6724: | * @static |
| 6725: | */ |
| 6726: | public static function moveDirectory($from, $to, $overwrite = false) |
| 6727: | { |
| 6728: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6729: | return $instance->moveDirectory($from, $to, $overwrite); |
| 6730: | } |
| 6731: | /** |
| 6732: | * Copy a directory from one location to another. |
| 6733: | * |
| 6734: | * @param string $directory |
| 6735: | * @param string $destination |
| 6736: | * @param int|null $options |
| 6737: | * @return bool |
| 6738: | * @static |
| 6739: | */ |
| 6740: | public static function copyDirectory($directory, $destination, $options = null) |
| 6741: | { |
| 6742: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6743: | return $instance->copyDirectory($directory, $destination, $options); |
| 6744: | } |
| 6745: | /** |
| 6746: | * Recursively delete a directory. |
| 6747: | * |
| 6748: | * The directory itself may be optionally preserved. |
| 6749: | * |
| 6750: | * @param string $directory |
| 6751: | * @param bool $preserve |
| 6752: | * @return bool |
| 6753: | * @static |
| 6754: | */ |
| 6755: | public static function deleteDirectory($directory, $preserve = false) |
| 6756: | { |
| 6757: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6758: | return $instance->deleteDirectory($directory, $preserve); |
| 6759: | } |
| 6760: | /** |
| 6761: | * Remove all of the directories within a given directory. |
| 6762: | * |
| 6763: | * @param string $directory |
| 6764: | * @return bool |
| 6765: | * @static |
| 6766: | */ |
| 6767: | public static function deleteDirectories($directory) |
| 6768: | { |
| 6769: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6770: | return $instance->deleteDirectories($directory); |
| 6771: | } |
| 6772: | /** |
| 6773: | * Empty the specified directory of all files and folders. |
| 6774: | * |
| 6775: | * @param string $directory |
| 6776: | * @return bool |
| 6777: | * @static |
| 6778: | */ |
| 6779: | public static function cleanDirectory($directory) |
| 6780: | { |
| 6781: | /** @var \Illuminate\Filesystem\Filesystem $instance */ |
| 6782: | return $instance->cleanDirectory($directory); |
| 6783: | } |
| 6784: | /** |
| 6785: | * Register a custom macro. |
| 6786: | * |
| 6787: | * @param string $name |
| 6788: | * @param object|callable $macro |
| 6789: | * @return void |
| 6790: | * @static |
| 6791: | */ |
| 6792: | public static function macro($name, $macro) |
| 6793: | { |
| 6794: | \Illuminate\Filesystem\Filesystem::macro($name, $macro); |
| 6795: | } |
| 6796: | /** |
| 6797: | * Mix another object into the class. |
| 6798: | * |
| 6799: | * @param object $mixin |
| 6800: | * @param bool $replace |
| 6801: | * @return void |
| 6802: | * @throws \ReflectionException |
| 6803: | * @static |
| 6804: | */ |
| 6805: | public static function mixin($mixin, $replace = true) |
| 6806: | { |
| 6807: | \Illuminate\Filesystem\Filesystem::mixin($mixin, $replace); |
| 6808: | } |
| 6809: | /** |
| 6810: | * Checks if macro is registered. |
| 6811: | * |
| 6812: | * @param string $name |
| 6813: | * @return bool |
| 6814: | * @static |
| 6815: | */ |
| 6816: | public static function hasMacro($name) |
| 6817: | { |
| 6818: | return \Illuminate\Filesystem\Filesystem::hasMacro($name); |
| 6819: | } |
| 6820: | /** |
| 6821: | * Flush the existing macros. |
| 6822: | * |
| 6823: | * @return void |
| 6824: | * @static |
| 6825: | */ |
| 6826: | public static function flushMacros() |
| 6827: | { |
| 6828: | \Illuminate\Filesystem\Filesystem::flushMacros(); |
| 6829: | } |
| 6830: | /** |
| 6831: | * |
| 6832: | * |
| 6833: | * @see \Blueprint\FileMixins::stub() |
| 6834: | * @param mixed $path |
| 6835: | * @static |
| 6836: | */ |
| 6837: | public static function stub($path) |
| 6838: | { |
| 6839: | return \Illuminate\Filesystem\Filesystem::stub($path); |
| 6840: | } |
| 6841: | |
| 6842: | } |
| 6843: | /** |
| 6844: | * |
| 6845: | * |
| 6846: | * @see \Illuminate\Contracts\Auth\Access\Gate |
| 6847: | */ |
| 6848: | class Gate { |
| 6849: | /** |
| 6850: | * Determine if a given ability has been defined. |
| 6851: | * |
| 6852: | * @param string|array $ability |
| 6853: | * @return bool |
| 6854: | * @static |
| 6855: | */ |
| 6856: | public static function has($ability) |
| 6857: | { |
| 6858: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 6859: | return $instance->has($ability); |
| 6860: | } |
| 6861: | /** |
| 6862: | * Perform an on-demand authorization check. Throw an authorization exception if the condition or callback is false. |
| 6863: | * |
| 6864: | * @param \Illuminate\Auth\Access\Response|\Closure|bool $condition |
| 6865: | * @param string|null $message |
| 6866: | * @param string|null $code |
| 6867: | * @return \Illuminate\Auth\Access\Response |
| 6868: | * @throws \Illuminate\Auth\Access\AuthorizationException |
| 6869: | * @static |
| 6870: | */ |
| 6871: | public static function allowIf($condition, $message = null, $code = null) |
| 6872: | { |
| 6873: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 6874: | return $instance->allowIf($condition, $message, $code); |
| 6875: | } |
| 6876: | /** |
| 6877: | * Perform an on-demand authorization check. Throw an authorization exception if the condition or callback is true. |
| 6878: | * |
| 6879: | * @param \Illuminate\Auth\Access\Response|\Closure|bool $condition |
| 6880: | * @param string|null $message |
| 6881: | * @param string|null $code |
| 6882: | * @return \Illuminate\Auth\Access\Response |
| 6883: | * @throws \Illuminate\Auth\Access\AuthorizationException |
| 6884: | * @static |
| 6885: | */ |
| 6886: | public static function denyIf($condition, $message = null, $code = null) |
| 6887: | { |
| 6888: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 6889: | return $instance->denyIf($condition, $message, $code); |
| 6890: | } |
| 6891: | /** |
| 6892: | * Define a new ability. |
| 6893: | * |
| 6894: | * @param string $ability |
| 6895: | * @param callable|array|string $callback |
| 6896: | * @return \Illuminate\Auth\Access\Gate |
| 6897: | * @throws \InvalidArgumentException |
| 6898: | * @static |
| 6899: | */ |
| 6900: | public static function define($ability, $callback) |
| 6901: | { |
| 6902: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 6903: | return $instance->define($ability, $callback); |
| 6904: | } |
| 6905: | /** |
| 6906: | * Define abilities for a resource. |
| 6907: | * |
| 6908: | * @param string $name |
| 6909: | * @param string $class |
| 6910: | * @param array|null $abilities |
| 6911: | * @return \Illuminate\Auth\Access\Gate |
| 6912: | * @static |
| 6913: | */ |
| 6914: | public static function resource($name, $class, $abilities = null) |
| 6915: | { |
| 6916: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 6917: | return $instance->resource($name, $class, $abilities); |
| 6918: | } |
| 6919: | /** |
| 6920: | * Define a policy class for a given class type. |
| 6921: | * |
| 6922: | * @param string $class |
| 6923: | * @param string $policy |
| 6924: | * @return \Illuminate\Auth\Access\Gate |
| 6925: | * @static |
| 6926: | */ |
| 6927: | public static function policy($class, $policy) |
| 6928: | { |
| 6929: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 6930: | return $instance->policy($class, $policy); |
| 6931: | } |
| 6932: | /** |
| 6933: | * Register a callback to run before all Gate checks. |
| 6934: | * |
| 6935: | * @param callable $callback |
| 6936: | * @return \Illuminate\Auth\Access\Gate |
| 6937: | * @static |
| 6938: | */ |
| 6939: | public static function before($callback) |
| 6940: | { |
| 6941: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 6942: | return $instance->before($callback); |
| 6943: | } |
| 6944: | /** |
| 6945: | * Register a callback to run after all Gate checks. |
| 6946: | * |
| 6947: | * @param callable $callback |
| 6948: | * @return \Illuminate\Auth\Access\Gate |
| 6949: | * @static |
| 6950: | */ |
| 6951: | public static function after($callback) |
| 6952: | { |
| 6953: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 6954: | return $instance->after($callback); |
| 6955: | } |
| 6956: | /** |
| 6957: | * Determine if the given ability should be granted for the current user. |
| 6958: | * |
| 6959: | * @param string $ability |
| 6960: | * @param array|mixed $arguments |
| 6961: | * @return bool |
| 6962: | * @static |
| 6963: | */ |
| 6964: | public static function allows($ability, $arguments = []) |
| 6965: | { |
| 6966: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 6967: | return $instance->allows($ability, $arguments); |
| 6968: | } |
| 6969: | /** |
| 6970: | * Determine if the given ability should be denied for the current user. |
| 6971: | * |
| 6972: | * @param string $ability |
| 6973: | * @param array|mixed $arguments |
| 6974: | * @return bool |
| 6975: | * @static |
| 6976: | */ |
| 6977: | public static function denies($ability, $arguments = []) |
| 6978: | { |
| 6979: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 6980: | return $instance->denies($ability, $arguments); |
| 6981: | } |
| 6982: | /** |
| 6983: | * Determine if all of the given abilities should be granted for the current user. |
| 6984: | * |
| 6985: | * @param \Illuminate\Auth\Access\iterable|string $abilities |
| 6986: | * @param array|mixed $arguments |
| 6987: | * @return bool |
| 6988: | * @static |
| 6989: | */ |
| 6990: | public static function check($abilities, $arguments = []) |
| 6991: | { |
| 6992: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 6993: | return $instance->check($abilities, $arguments); |
| 6994: | } |
| 6995: | /** |
| 6996: | * Determine if any one of the given abilities should be granted for the current user. |
| 6997: | * |
| 6998: | * @param \Illuminate\Auth\Access\iterable|string $abilities |
| 6999: | * @param array|mixed $arguments |
| 7000: | * @return bool |
| 7001: | * @static |
| 7002: | */ |
| 7003: | public static function any($abilities, $arguments = []) |
| 7004: | { |
| 7005: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7006: | return $instance->any($abilities, $arguments); |
| 7007: | } |
| 7008: | /** |
| 7009: | * Determine if all of the given abilities should be denied for the current user. |
| 7010: | * |
| 7011: | * @param \Illuminate\Auth\Access\iterable|string $abilities |
| 7012: | * @param array|mixed $arguments |
| 7013: | * @return bool |
| 7014: | * @static |
| 7015: | */ |
| 7016: | public static function none($abilities, $arguments = []) |
| 7017: | { |
| 7018: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7019: | return $instance->none($abilities, $arguments); |
| 7020: | } |
| 7021: | /** |
| 7022: | * Determine if the given ability should be granted for the current user. |
| 7023: | * |
| 7024: | * @param string $ability |
| 7025: | * @param array|mixed $arguments |
| 7026: | * @return \Illuminate\Auth\Access\Response |
| 7027: | * @throws \Illuminate\Auth\Access\AuthorizationException |
| 7028: | * @static |
| 7029: | */ |
| 7030: | public static function authorize($ability, $arguments = []) |
| 7031: | { |
| 7032: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7033: | return $instance->authorize($ability, $arguments); |
| 7034: | } |
| 7035: | /** |
| 7036: | * Inspect the user for the given ability. |
| 7037: | * |
| 7038: | * @param string $ability |
| 7039: | * @param array|mixed $arguments |
| 7040: | * @return \Illuminate\Auth\Access\Response |
| 7041: | * @static |
| 7042: | */ |
| 7043: | public static function inspect($ability, $arguments = []) |
| 7044: | { |
| 7045: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7046: | return $instance->inspect($ability, $arguments); |
| 7047: | } |
| 7048: | /** |
| 7049: | * Get the raw result from the authorization callback. |
| 7050: | * |
| 7051: | * @param string $ability |
| 7052: | * @param array|mixed $arguments |
| 7053: | * @return mixed |
| 7054: | * @throws \Illuminate\Auth\Access\AuthorizationException |
| 7055: | * @static |
| 7056: | */ |
| 7057: | public static function raw($ability, $arguments = []) |
| 7058: | { |
| 7059: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7060: | return $instance->raw($ability, $arguments); |
| 7061: | } |
| 7062: | /** |
| 7063: | * Get a policy instance for a given class. |
| 7064: | * |
| 7065: | * @param object|string $class |
| 7066: | * @return mixed |
| 7067: | * @static |
| 7068: | */ |
| 7069: | public static function getPolicyFor($class) |
| 7070: | { |
| 7071: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7072: | return $instance->getPolicyFor($class); |
| 7073: | } |
| 7074: | /** |
| 7075: | * Specify a callback to be used to guess policy names. |
| 7076: | * |
| 7077: | * @param callable $callback |
| 7078: | * @return \Illuminate\Auth\Access\Gate |
| 7079: | * @static |
| 7080: | */ |
| 7081: | public static function guessPolicyNamesUsing($callback) |
| 7082: | { |
| 7083: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7084: | return $instance->guessPolicyNamesUsing($callback); |
| 7085: | } |
| 7086: | /** |
| 7087: | * Build a policy class instance of the given type. |
| 7088: | * |
| 7089: | * @param object|string $class |
| 7090: | * @return mixed |
| 7091: | * @throws \Illuminate\Contracts\Container\BindingResolutionException |
| 7092: | * @static |
| 7093: | */ |
| 7094: | public static function resolvePolicy($class) |
| 7095: | { |
| 7096: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7097: | return $instance->resolvePolicy($class); |
| 7098: | } |
| 7099: | /** |
| 7100: | * Get a gate instance for the given user. |
| 7101: | * |
| 7102: | * @param \Illuminate\Contracts\Auth\Authenticatable|mixed $user |
| 7103: | * @return static |
| 7104: | * @static |
| 7105: | */ |
| 7106: | public static function forUser($user) |
| 7107: | { |
| 7108: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7109: | return $instance->forUser($user); |
| 7110: | } |
| 7111: | /** |
| 7112: | * Get all of the defined abilities. |
| 7113: | * |
| 7114: | * @return array |
| 7115: | * @static |
| 7116: | */ |
| 7117: | public static function abilities() |
| 7118: | { |
| 7119: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7120: | return $instance->abilities(); |
| 7121: | } |
| 7122: | /** |
| 7123: | * Get all of the defined policies. |
| 7124: | * |
| 7125: | * @return array |
| 7126: | * @static |
| 7127: | */ |
| 7128: | public static function policies() |
| 7129: | { |
| 7130: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7131: | return $instance->policies(); |
| 7132: | } |
| 7133: | /** |
| 7134: | * Set the container instance used by the gate. |
| 7135: | * |
| 7136: | * @param \Illuminate\Contracts\Container\Container $container |
| 7137: | * @return \Illuminate\Auth\Access\Gate |
| 7138: | * @static |
| 7139: | */ |
| 7140: | public static function setContainer($container) |
| 7141: | { |
| 7142: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7143: | return $instance->setContainer($container); |
| 7144: | } |
| 7145: | /** |
| 7146: | * Deny with a HTTP status code. |
| 7147: | * |
| 7148: | * @param int $status |
| 7149: | * @param \Illuminate\Auth\Access\?string $message |
| 7150: | * @param \Illuminate\Auth\Access\?int $code |
| 7151: | * @return \Illuminate\Auth\Access\Response |
| 7152: | * @static |
| 7153: | */ |
| 7154: | public static function denyWithStatus($status, $message = null, $code = null) |
| 7155: | { |
| 7156: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7157: | return $instance->denyWithStatus($status, $message, $code); |
| 7158: | } |
| 7159: | /** |
| 7160: | * Deny with a 404 HTTP status code. |
| 7161: | * |
| 7162: | * @param \Illuminate\Auth\Access\?string $message |
| 7163: | * @param \Illuminate\Auth\Access\?int $code |
| 7164: | * @return \Illuminate\Auth\Access\Response |
| 7165: | * @static |
| 7166: | */ |
| 7167: | public static function denyAsNotFound($message = null, $code = null) |
| 7168: | { |
| 7169: | /** @var \Illuminate\Auth\Access\Gate $instance */ |
| 7170: | return $instance->denyAsNotFound($message, $code); |
| 7171: | } |
| 7172: | |
| 7173: | } |
| 7174: | /** |
| 7175: | * |
| 7176: | * |
| 7177: | * @see \Illuminate\Hashing\HashManager |
| 7178: | */ |
| 7179: | class Hash { |
| 7180: | /** |
| 7181: | * Create an instance of the Bcrypt hash Driver. |
| 7182: | * |
| 7183: | * @return \Illuminate\Hashing\BcryptHasher |
| 7184: | * @static |
| 7185: | */ |
| 7186: | public static function createBcryptDriver() |
| 7187: | { |
| 7188: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7189: | return $instance->createBcryptDriver(); |
| 7190: | } |
| 7191: | /** |
| 7192: | * Create an instance of the Argon2i hash Driver. |
| 7193: | * |
| 7194: | * @return \Illuminate\Hashing\ArgonHasher |
| 7195: | * @static |
| 7196: | */ |
| 7197: | public static function createArgonDriver() |
| 7198: | { |
| 7199: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7200: | return $instance->createArgonDriver(); |
| 7201: | } |
| 7202: | /** |
| 7203: | * Create an instance of the Argon2id hash Driver. |
| 7204: | * |
| 7205: | * @return \Illuminate\Hashing\Argon2IdHasher |
| 7206: | * @static |
| 7207: | */ |
| 7208: | public static function createArgon2idDriver() |
| 7209: | { |
| 7210: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7211: | return $instance->createArgon2idDriver(); |
| 7212: | } |
| 7213: | /** |
| 7214: | * Get information about the given hashed value. |
| 7215: | * |
| 7216: | * @param string $hashedValue |
| 7217: | * @return array |
| 7218: | * @static |
| 7219: | */ |
| 7220: | public static function info($hashedValue) |
| 7221: | { |
| 7222: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7223: | return $instance->info($hashedValue); |
| 7224: | } |
| 7225: | /** |
| 7226: | * Hash the given value. |
| 7227: | * |
| 7228: | * @param string $value |
| 7229: | * @param array $options |
| 7230: | * @return string |
| 7231: | * @static |
| 7232: | */ |
| 7233: | public static function make($value, $options = []) |
| 7234: | { |
| 7235: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7236: | return $instance->make($value, $options); |
| 7237: | } |
| 7238: | /** |
| 7239: | * Check the given plain value against a hash. |
| 7240: | * |
| 7241: | * @param string $value |
| 7242: | * @param string $hashedValue |
| 7243: | * @param array $options |
| 7244: | * @return bool |
| 7245: | * @static |
| 7246: | */ |
| 7247: | public static function check($value, $hashedValue, $options = []) |
| 7248: | { |
| 7249: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7250: | return $instance->check($value, $hashedValue, $options); |
| 7251: | } |
| 7252: | /** |
| 7253: | * Check if the given hash has been hashed using the given options. |
| 7254: | * |
| 7255: | * @param string $hashedValue |
| 7256: | * @param array $options |
| 7257: | * @return bool |
| 7258: | * @static |
| 7259: | */ |
| 7260: | public static function needsRehash($hashedValue, $options = []) |
| 7261: | { |
| 7262: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7263: | return $instance->needsRehash($hashedValue, $options); |
| 7264: | } |
| 7265: | /** |
| 7266: | * Get the default driver name. |
| 7267: | * |
| 7268: | * @return string |
| 7269: | * @static |
| 7270: | */ |
| 7271: | public static function getDefaultDriver() |
| 7272: | { |
| 7273: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7274: | return $instance->getDefaultDriver(); |
| 7275: | } |
| 7276: | /** |
| 7277: | * Get a driver instance. |
| 7278: | * |
| 7279: | * @param string|null $driver |
| 7280: | * @return mixed |
| 7281: | * @throws \InvalidArgumentException |
| 7282: | * @static |
| 7283: | */ |
| 7284: | public static function driver($driver = null) |
| 7285: | { //Method inherited from \Illuminate\Support\Manager |
| 7286: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7287: | return $instance->driver($driver); |
| 7288: | } |
| 7289: | /** |
| 7290: | * Register a custom driver creator Closure. |
| 7291: | * |
| 7292: | * @param string $driver |
| 7293: | * @param \Closure $callback |
| 7294: | * @return \Illuminate\Hashing\HashManager |
| 7295: | * @static |
| 7296: | */ |
| 7297: | public static function extend($driver, $callback) |
| 7298: | { //Method inherited from \Illuminate\Support\Manager |
| 7299: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7300: | return $instance->extend($driver, $callback); |
| 7301: | } |
| 7302: | /** |
| 7303: | * Get all of the created "drivers". |
| 7304: | * |
| 7305: | * @return array |
| 7306: | * @static |
| 7307: | */ |
| 7308: | public static function getDrivers() |
| 7309: | { //Method inherited from \Illuminate\Support\Manager |
| 7310: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7311: | return $instance->getDrivers(); |
| 7312: | } |
| 7313: | /** |
| 7314: | * Get the container instance used by the manager. |
| 7315: | * |
| 7316: | * @return \Illuminate\Contracts\Container\Container |
| 7317: | * @static |
| 7318: | */ |
| 7319: | public static function getContainer() |
| 7320: | { //Method inherited from \Illuminate\Support\Manager |
| 7321: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7322: | return $instance->getContainer(); |
| 7323: | } |
| 7324: | /** |
| 7325: | * Set the container instance used by the manager. |
| 7326: | * |
| 7327: | * @param \Illuminate\Contracts\Container\Container $container |
| 7328: | * @return \Illuminate\Hashing\HashManager |
| 7329: | * @static |
| 7330: | */ |
| 7331: | public static function setContainer($container) |
| 7332: | { //Method inherited from \Illuminate\Support\Manager |
| 7333: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7334: | return $instance->setContainer($container); |
| 7335: | } |
| 7336: | /** |
| 7337: | * Forget all of the resolved driver instances. |
| 7338: | * |
| 7339: | * @return \Illuminate\Hashing\HashManager |
| 7340: | * @static |
| 7341: | */ |
| 7342: | public static function forgetDrivers() |
| 7343: | { //Method inherited from \Illuminate\Support\Manager |
| 7344: | /** @var \Illuminate\Hashing\HashManager $instance */ |
| 7345: | return $instance->forgetDrivers(); |
| 7346: | } |
| 7347: | |
| 7348: | } |
| 7349: | /** |
| 7350: | * |
| 7351: | * |
| 7352: | * @method static \Illuminate\Http\Client\PendingRequest accept(string $contentType) |
| 7353: | * @method static \Illuminate\Http\Client\PendingRequest acceptJson() |
| 7354: | * @method static \Illuminate\Http\Client\PendingRequest asForm() |
| 7355: | * @method static \Illuminate\Http\Client\PendingRequest asJson() |
| 7356: | * @method static \Illuminate\Http\Client\PendingRequest asMultipart() |
| 7357: | * @method static \Illuminate\Http\Client\PendingRequest async() |
| 7358: | * @method static \Illuminate\Http\Client\PendingRequest attach(string|array $name, string $contents = '', string|null $filename = null, array $headers = []) |
| 7359: | * @method static \Illuminate\Http\Client\PendingRequest baseUrl(string $url) |
| 7360: | * @method static \Illuminate\Http\Client\PendingRequest beforeSending(callable $callback) |
| 7361: | * @method static \Illuminate\Http\Client\PendingRequest bodyFormat(string $format) |
| 7362: | * @method static \Illuminate\Http\Client\PendingRequest connectTimeout(int $seconds) |
| 7363: | * @method static \Illuminate\Http\Client\PendingRequest contentType(string $contentType) |
| 7364: | * @method static \Illuminate\Http\Client\PendingRequest dd() |
| 7365: | * @method static \Illuminate\Http\Client\PendingRequest dump() |
| 7366: | * @method static \Illuminate\Http\Client\PendingRequest maxRedirects(int $max) |
| 7367: | * @method static \Illuminate\Http\Client\PendingRequest retry(int $times, int $sleepMilliseconds = 0, ?callable $when = null, bool $throw = true) |
| 7368: | * @method static \Illuminate\Http\Client\PendingRequest sink(string|resource $to) |
| 7369: | * @method static \Illuminate\Http\Client\PendingRequest stub(callable $callback) |
| 7370: | * @method static \Illuminate\Http\Client\PendingRequest timeout(int $seconds) |
| 7371: | * @method static \Illuminate\Http\Client\PendingRequest withBasicAuth(string $username, string $password) |
| 7372: | * @method static \Illuminate\Http\Client\PendingRequest withBody(resource|string $content, string $contentType) |
| 7373: | * @method static \Illuminate\Http\Client\PendingRequest withCookies(array $cookies, string $domain) |
| 7374: | * @method static \Illuminate\Http\Client\PendingRequest withDigestAuth(string $username, string $password) |
| 7375: | * @method static \Illuminate\Http\Client\PendingRequest withHeaders(array $headers) |
| 7376: | * @method static \Illuminate\Http\Client\PendingRequest withMiddleware(callable $middleware) |
| 7377: | * @method static \Illuminate\Http\Client\PendingRequest withOptions(array $options) |
| 7378: | * @method static \Illuminate\Http\Client\PendingRequest withToken(string $token, string $type = 'Bearer') |
| 7379: | * @method static \Illuminate\Http\Client\PendingRequest withUserAgent(string $userAgent) |
| 7380: | * @method static \Illuminate\Http\Client\PendingRequest withoutRedirecting() |
| 7381: | * @method static \Illuminate\Http\Client\PendingRequest withoutVerifying() |
| 7382: | * @method static \Illuminate\Http\Client\PendingRequest throw(callable $callback = null) |
| 7383: | * @method static \Illuminate\Http\Client\PendingRequest throwIf($condition) |
| 7384: | * @method \Illuminate\Http\Client\PendingRequest throwUnless($condition) |
| 7385: | * @method static array pool(callable $callback) |
| 7386: | * @method static \Illuminate\Http\Client\Response delete(string $url, array $data = []) |
| 7387: | * @method static \Illuminate\Http\Client\Response get(string $url, array|string|null $query = null) |
| 7388: | * @method static \Illuminate\Http\Client\Response head(string $url, array|string|null $query = null) |
| 7389: | * @method static \Illuminate\Http\Client\Response patch(string $url, array $data = []) |
| 7390: | * @method static \Illuminate\Http\Client\Response post(string $url, array $data = []) |
| 7391: | * @method static \Illuminate\Http\Client\Response put(string $url, array $data = []) |
| 7392: | * @method static \Illuminate\Http\Client\Response send(string $method, string $url, array $options = []) |
| 7393: | * @see \Illuminate\Http\Client\Factory |
| 7394: | */ |
| 7395: | class Http { |
| 7396: | /** |
| 7397: | * Create a new response instance for use during stubbing. |
| 7398: | * |
| 7399: | * @param array|string|null $body |
| 7400: | * @param int $status |
| 7401: | * @param array $headers |
| 7402: | * @return \GuzzleHttp\Promise\PromiseInterface |
| 7403: | * @static |
| 7404: | */ |
| 7405: | public static function response($body = null, $status = 200, $headers = []) |
| 7406: | { |
| 7407: | return \Illuminate\Http\Client\Factory::response($body, $status, $headers); |
| 7408: | } |
| 7409: | /** |
| 7410: | * Get an invokable object that returns a sequence of responses in order for use during stubbing. |
| 7411: | * |
| 7412: | * @param array $responses |
| 7413: | * @return \Illuminate\Http\Client\ResponseSequence |
| 7414: | * @static |
| 7415: | */ |
| 7416: | public static function sequence($responses = []) |
| 7417: | { |
| 7418: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7419: | return $instance->sequence($responses); |
| 7420: | } |
| 7421: | /** |
| 7422: | * Register a stub callable that will intercept requests and be able to return stub responses. |
| 7423: | * |
| 7424: | * @param callable|array $callback |
| 7425: | * @return \Illuminate\Http\Client\Factory |
| 7426: | * @static |
| 7427: | */ |
| 7428: | public static function fake($callback = null) |
| 7429: | { |
| 7430: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7431: | return $instance->fake($callback); |
| 7432: | } |
| 7433: | /** |
| 7434: | * Register a response sequence for the given URL pattern. |
| 7435: | * |
| 7436: | * @param string $url |
| 7437: | * @return \Illuminate\Http\Client\ResponseSequence |
| 7438: | * @static |
| 7439: | */ |
| 7440: | public static function fakeSequence($url = '*') |
| 7441: | { |
| 7442: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7443: | return $instance->fakeSequence($url); |
| 7444: | } |
| 7445: | /** |
| 7446: | * Stub the given URL using the given callback. |
| 7447: | * |
| 7448: | * @param string $url |
| 7449: | * @param \Illuminate\Http\Client\Response|\GuzzleHttp\Promise\PromiseInterface|callable $callback |
| 7450: | * @return \Illuminate\Http\Client\Factory |
| 7451: | * @static |
| 7452: | */ |
| 7453: | public static function stubUrl($url, $callback) |
| 7454: | { |
| 7455: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7456: | return $instance->stubUrl($url, $callback); |
| 7457: | } |
| 7458: | /** |
| 7459: | * Indicate that an exception should be thrown if any request is not faked. |
| 7460: | * |
| 7461: | * @param bool $prevent |
| 7462: | * @return \Illuminate\Http\Client\Factory |
| 7463: | * @static |
| 7464: | */ |
| 7465: | public static function preventStrayRequests($prevent = true) |
| 7466: | { |
| 7467: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7468: | return $instance->preventStrayRequests($prevent); |
| 7469: | } |
| 7470: | /** |
| 7471: | * Indicate that an exception should not be thrown if any request is not faked. |
| 7472: | * |
| 7473: | * @return \Illuminate\Http\Client\Factory |
| 7474: | * @static |
| 7475: | */ |
| 7476: | public static function allowStrayRequests() |
| 7477: | { |
| 7478: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7479: | return $instance->allowStrayRequests(); |
| 7480: | } |
| 7481: | /** |
| 7482: | * Record a request response pair. |
| 7483: | * |
| 7484: | * @param \Illuminate\Http\Client\Request $request |
| 7485: | * @param \Illuminate\Http\Client\Response $response |
| 7486: | * @return void |
| 7487: | * @static |
| 7488: | */ |
| 7489: | public static function recordRequestResponsePair($request, $response) |
| 7490: | { |
| 7491: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7492: | $instance->recordRequestResponsePair($request, $response); |
| 7493: | } |
| 7494: | /** |
| 7495: | * Assert that a request / response pair was recorded matching a given truth test. |
| 7496: | * |
| 7497: | * @param callable $callback |
| 7498: | * @return void |
| 7499: | * @static |
| 7500: | */ |
| 7501: | public static function assertSent($callback) |
| 7502: | { |
| 7503: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7504: | $instance->assertSent($callback); |
| 7505: | } |
| 7506: | /** |
| 7507: | * Assert that the given request was sent in the given order. |
| 7508: | * |
| 7509: | * @param array $callbacks |
| 7510: | * @return void |
| 7511: | * @static |
| 7512: | */ |
| 7513: | public static function assertSentInOrder($callbacks) |
| 7514: | { |
| 7515: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7516: | $instance->assertSentInOrder($callbacks); |
| 7517: | } |
| 7518: | /** |
| 7519: | * Assert that a request / response pair was not recorded matching a given truth test. |
| 7520: | * |
| 7521: | * @param callable $callback |
| 7522: | * @return void |
| 7523: | * @static |
| 7524: | */ |
| 7525: | public static function assertNotSent($callback) |
| 7526: | { |
| 7527: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7528: | $instance->assertNotSent($callback); |
| 7529: | } |
| 7530: | /** |
| 7531: | * Assert that no request / response pair was recorded. |
| 7532: | * |
| 7533: | * @return void |
| 7534: | * @static |
| 7535: | */ |
| 7536: | public static function assertNothingSent() |
| 7537: | { |
| 7538: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7539: | $instance->assertNothingSent(); |
| 7540: | } |
| 7541: | /** |
| 7542: | * Assert how many requests have been recorded. |
| 7543: | * |
| 7544: | * @param int $count |
| 7545: | * @return void |
| 7546: | * @static |
| 7547: | */ |
| 7548: | public static function assertSentCount($count) |
| 7549: | { |
| 7550: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7551: | $instance->assertSentCount($count); |
| 7552: | } |
| 7553: | /** |
| 7554: | * Assert that every created response sequence is empty. |
| 7555: | * |
| 7556: | * @return void |
| 7557: | * @static |
| 7558: | */ |
| 7559: | public static function assertSequencesAreEmpty() |
| 7560: | { |
| 7561: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7562: | $instance->assertSequencesAreEmpty(); |
| 7563: | } |
| 7564: | /** |
| 7565: | * Get a collection of the request / response pairs matching the given truth test. |
| 7566: | * |
| 7567: | * @param callable $callback |
| 7568: | * @return \Illuminate\Support\Collection |
| 7569: | * @static |
| 7570: | */ |
| 7571: | public static function recorded($callback = null) |
| 7572: | { |
| 7573: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7574: | return $instance->recorded($callback); |
| 7575: | } |
| 7576: | /** |
| 7577: | * Get the current event dispatcher implementation. |
| 7578: | * |
| 7579: | * @return \Illuminate\Contracts\Events\Dispatcher|null |
| 7580: | * @static |
| 7581: | */ |
| 7582: | public static function getDispatcher() |
| 7583: | { |
| 7584: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7585: | return $instance->getDispatcher(); |
| 7586: | } |
| 7587: | /** |
| 7588: | * Register a custom macro. |
| 7589: | * |
| 7590: | * @param string $name |
| 7591: | * @param object|callable $macro |
| 7592: | * @return void |
| 7593: | * @static |
| 7594: | */ |
| 7595: | public static function macro($name, $macro) |
| 7596: | { |
| 7597: | \Illuminate\Http\Client\Factory::macro($name, $macro); |
| 7598: | } |
| 7599: | /** |
| 7600: | * Mix another object into the class. |
| 7601: | * |
| 7602: | * @param object $mixin |
| 7603: | * @param bool $replace |
| 7604: | * @return void |
| 7605: | * @throws \ReflectionException |
| 7606: | * @static |
| 7607: | */ |
| 7608: | public static function mixin($mixin, $replace = true) |
| 7609: | { |
| 7610: | \Illuminate\Http\Client\Factory::mixin($mixin, $replace); |
| 7611: | } |
| 7612: | /** |
| 7613: | * Checks if macro is registered. |
| 7614: | * |
| 7615: | * @param string $name |
| 7616: | * @return bool |
| 7617: | * @static |
| 7618: | */ |
| 7619: | public static function hasMacro($name) |
| 7620: | { |
| 7621: | return \Illuminate\Http\Client\Factory::hasMacro($name); |
| 7622: | } |
| 7623: | /** |
| 7624: | * Flush the existing macros. |
| 7625: | * |
| 7626: | * @return void |
| 7627: | * @static |
| 7628: | */ |
| 7629: | public static function flushMacros() |
| 7630: | { |
| 7631: | \Illuminate\Http\Client\Factory::flushMacros(); |
| 7632: | } |
| 7633: | /** |
| 7634: | * Dynamically handle calls to the class. |
| 7635: | * |
| 7636: | * @param string $method |
| 7637: | * @param array $parameters |
| 7638: | * @return mixed |
| 7639: | * @throws \BadMethodCallException |
| 7640: | * @static |
| 7641: | */ |
| 7642: | public static function macroCall($method, $parameters) |
| 7643: | { |
| 7644: | /** @var \Illuminate\Http\Client\Factory $instance */ |
| 7645: | return $instance->macroCall($method, $parameters); |
| 7646: | } |
| 7647: | |
| 7648: | } |
| 7649: | /** |
| 7650: | * |
| 7651: | * |
| 7652: | * @see \Illuminate\Translation\Translator |
| 7653: | */ |
| 7654: | class Lang { |
| 7655: | /** |
| 7656: | * Determine if a translation exists for a given locale. |
| 7657: | * |
| 7658: | * @param string $key |
| 7659: | * @param string|null $locale |
| 7660: | * @return bool |
| 7661: | * @static |
| 7662: | */ |
| 7663: | public static function hasForLocale($key, $locale = null) |
| 7664: | { |
| 7665: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7666: | return $instance->hasForLocale($key, $locale); |
| 7667: | } |
| 7668: | /** |
| 7669: | * Determine if a translation exists. |
| 7670: | * |
| 7671: | * @param string $key |
| 7672: | * @param string|null $locale |
| 7673: | * @param bool $fallback |
| 7674: | * @return bool |
| 7675: | * @static |
| 7676: | */ |
| 7677: | public static function has($key, $locale = null, $fallback = true) |
| 7678: | { |
| 7679: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7680: | return $instance->has($key, $locale, $fallback); |
| 7681: | } |
| 7682: | /** |
| 7683: | * Get the translation for the given key. |
| 7684: | * |
| 7685: | * @param string $key |
| 7686: | * @param array $replace |
| 7687: | * @param string|null $locale |
| 7688: | * @param bool $fallback |
| 7689: | * @return string|array |
| 7690: | * @static |
| 7691: | */ |
| 7692: | public static function get($key, $replace = [], $locale = null, $fallback = true) |
| 7693: | { |
| 7694: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7695: | return $instance->get($key, $replace, $locale, $fallback); |
| 7696: | } |
| 7697: | /** |
| 7698: | * Get a translation according to an integer value. |
| 7699: | * |
| 7700: | * @param string $key |
| 7701: | * @param \Countable|int|array $number |
| 7702: | * @param array $replace |
| 7703: | * @param string|null $locale |
| 7704: | * @return string |
| 7705: | * @static |
| 7706: | */ |
| 7707: | public static function choice($key, $number, $replace = [], $locale = null) |
| 7708: | { |
| 7709: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7710: | return $instance->choice($key, $number, $replace, $locale); |
| 7711: | } |
| 7712: | /** |
| 7713: | * Add translation lines to the given locale. |
| 7714: | * |
| 7715: | * @param array $lines |
| 7716: | * @param string $locale |
| 7717: | * @param string $namespace |
| 7718: | * @return void |
| 7719: | * @static |
| 7720: | */ |
| 7721: | public static function addLines($lines, $locale, $namespace = '*') |
| 7722: | { |
| 7723: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7724: | $instance->addLines($lines, $locale, $namespace); |
| 7725: | } |
| 7726: | /** |
| 7727: | * Load the specified language group. |
| 7728: | * |
| 7729: | * @param string $namespace |
| 7730: | * @param string $group |
| 7731: | * @param string $locale |
| 7732: | * @return void |
| 7733: | * @static |
| 7734: | */ |
| 7735: | public static function load($namespace, $group, $locale) |
| 7736: | { |
| 7737: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7738: | $instance->load($namespace, $group, $locale); |
| 7739: | } |
| 7740: | /** |
| 7741: | * Add a new namespace to the loader. |
| 7742: | * |
| 7743: | * @param string $namespace |
| 7744: | * @param string $hint |
| 7745: | * @return void |
| 7746: | * @static |
| 7747: | */ |
| 7748: | public static function addNamespace($namespace, $hint) |
| 7749: | { |
| 7750: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7751: | $instance->addNamespace($namespace, $hint); |
| 7752: | } |
| 7753: | /** |
| 7754: | * Add a new JSON path to the loader. |
| 7755: | * |
| 7756: | * @param string $path |
| 7757: | * @return void |
| 7758: | * @static |
| 7759: | */ |
| 7760: | public static function addJsonPath($path) |
| 7761: | { |
| 7762: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7763: | $instance->addJsonPath($path); |
| 7764: | } |
| 7765: | /** |
| 7766: | * Parse a key into namespace, group, and item. |
| 7767: | * |
| 7768: | * @param string $key |
| 7769: | * @return array |
| 7770: | * @static |
| 7771: | */ |
| 7772: | public static function parseKey($key) |
| 7773: | { |
| 7774: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7775: | return $instance->parseKey($key); |
| 7776: | } |
| 7777: | /** |
| 7778: | * Specify a callback that should be invoked to determined the applicable locale array. |
| 7779: | * |
| 7780: | * @param callable $callback |
| 7781: | * @return void |
| 7782: | * @static |
| 7783: | */ |
| 7784: | public static function determineLocalesUsing($callback) |
| 7785: | { |
| 7786: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7787: | $instance->determineLocalesUsing($callback); |
| 7788: | } |
| 7789: | /** |
| 7790: | * Get the message selector instance. |
| 7791: | * |
| 7792: | * @return \Illuminate\Translation\MessageSelector |
| 7793: | * @static |
| 7794: | */ |
| 7795: | public static function getSelector() |
| 7796: | { |
| 7797: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7798: | return $instance->getSelector(); |
| 7799: | } |
| 7800: | /** |
| 7801: | * Set the message selector instance. |
| 7802: | * |
| 7803: | * @param \Illuminate\Translation\MessageSelector $selector |
| 7804: | * @return void |
| 7805: | * @static |
| 7806: | */ |
| 7807: | public static function setSelector($selector) |
| 7808: | { |
| 7809: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7810: | $instance->setSelector($selector); |
| 7811: | } |
| 7812: | /** |
| 7813: | * Get the language line loader implementation. |
| 7814: | * |
| 7815: | * @return \Illuminate\Contracts\Translation\Loader |
| 7816: | * @static |
| 7817: | */ |
| 7818: | public static function getLoader() |
| 7819: | { |
| 7820: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7821: | return $instance->getLoader(); |
| 7822: | } |
| 7823: | /** |
| 7824: | * Get the default locale being used. |
| 7825: | * |
| 7826: | * @return string |
| 7827: | * @static |
| 7828: | */ |
| 7829: | public static function locale() |
| 7830: | { |
| 7831: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7832: | return $instance->locale(); |
| 7833: | } |
| 7834: | /** |
| 7835: | * Get the default locale being used. |
| 7836: | * |
| 7837: | * @return string |
| 7838: | * @static |
| 7839: | */ |
| 7840: | public static function getLocale() |
| 7841: | { |
| 7842: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7843: | return $instance->getLocale(); |
| 7844: | } |
| 7845: | /** |
| 7846: | * Set the default locale. |
| 7847: | * |
| 7848: | * @param string $locale |
| 7849: | * @return void |
| 7850: | * @throws \InvalidArgumentException |
| 7851: | * @static |
| 7852: | */ |
| 7853: | public static function setLocale($locale) |
| 7854: | { |
| 7855: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7856: | $instance->setLocale($locale); |
| 7857: | } |
| 7858: | /** |
| 7859: | * Get the fallback locale being used. |
| 7860: | * |
| 7861: | * @return string |
| 7862: | * @static |
| 7863: | */ |
| 7864: | public static function getFallback() |
| 7865: | { |
| 7866: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7867: | return $instance->getFallback(); |
| 7868: | } |
| 7869: | /** |
| 7870: | * Set the fallback locale being used. |
| 7871: | * |
| 7872: | * @param string $fallback |
| 7873: | * @return void |
| 7874: | * @static |
| 7875: | */ |
| 7876: | public static function setFallback($fallback) |
| 7877: | { |
| 7878: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7879: | $instance->setFallback($fallback); |
| 7880: | } |
| 7881: | /** |
| 7882: | * Set the loaded translation groups. |
| 7883: | * |
| 7884: | * @param array $loaded |
| 7885: | * @return void |
| 7886: | * @static |
| 7887: | */ |
| 7888: | public static function setLoaded($loaded) |
| 7889: | { |
| 7890: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7891: | $instance->setLoaded($loaded); |
| 7892: | } |
| 7893: | /** |
| 7894: | * Set the parsed value of a key. |
| 7895: | * |
| 7896: | * @param string $key |
| 7897: | * @param array $parsed |
| 7898: | * @return void |
| 7899: | * @static |
| 7900: | */ |
| 7901: | public static function setParsedKey($key, $parsed) |
| 7902: | { //Method inherited from \Illuminate\Support\NamespacedItemResolver |
| 7903: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7904: | $instance->setParsedKey($key, $parsed); |
| 7905: | } |
| 7906: | /** |
| 7907: | * Flush the cache of parsed keys. |
| 7908: | * |
| 7909: | * @return void |
| 7910: | * @static |
| 7911: | */ |
| 7912: | public static function flushParsedKeys() |
| 7913: | { //Method inherited from \Illuminate\Support\NamespacedItemResolver |
| 7914: | /** @var \Illuminate\Translation\Translator $instance */ |
| 7915: | $instance->flushParsedKeys(); |
| 7916: | } |
| 7917: | /** |
| 7918: | * Register a custom macro. |
| 7919: | * |
| 7920: | * @param string $name |
| 7921: | * @param object|callable $macro |
| 7922: | * @return void |
| 7923: | * @static |
| 7924: | */ |
| 7925: | public static function macro($name, $macro) |
| 7926: | { |
| 7927: | \Illuminate\Translation\Translator::macro($name, $macro); |
| 7928: | } |
| 7929: | /** |
| 7930: | * Mix another object into the class. |
| 7931: | * |
| 7932: | * @param object $mixin |
| 7933: | * @param bool $replace |
| 7934: | * @return void |
| 7935: | * @throws \ReflectionException |
| 7936: | * @static |
| 7937: | */ |
| 7938: | public static function mixin($mixin, $replace = true) |
| 7939: | { |
| 7940: | \Illuminate\Translation\Translator::mixin($mixin, $replace); |
| 7941: | } |
| 7942: | /** |
| 7943: | * Checks if macro is registered. |
| 7944: | * |
| 7945: | * @param string $name |
| 7946: | * @return bool |
| 7947: | * @static |
| 7948: | */ |
| 7949: | public static function hasMacro($name) |
| 7950: | { |
| 7951: | return \Illuminate\Translation\Translator::hasMacro($name); |
| 7952: | } |
| 7953: | /** |
| 7954: | * Flush the existing macros. |
| 7955: | * |
| 7956: | * @return void |
| 7957: | * @static |
| 7958: | */ |
| 7959: | public static function flushMacros() |
| 7960: | { |
| 7961: | \Illuminate\Translation\Translator::flushMacros(); |
| 7962: | } |
| 7963: | |
| 7964: | } |
| 7965: | /** |
| 7966: | * |
| 7967: | * |
| 7968: | * @method static \Illuminate\Log\Logger withContext(array $context = []) |
| 7969: | * @method static \Illuminate\Log\Logger withoutContext() |
| 7970: | * @method static void write(string $level, string $message, array $context = []) |
| 7971: | * @method static void listen(\Closure $callback) |
| 7972: | * @see \Illuminate\Log\Logger |
| 7973: | */ |
| 7974: | class Log { |
| 7975: | /** |
| 7976: | * Build an on-demand log channel. |
| 7977: | * |
| 7978: | * @param array $config |
| 7979: | * @return \Psr\Log\LoggerInterface |
| 7980: | * @static |
| 7981: | */ |
| 7982: | public static function build($config) |
| 7983: | { |
| 7984: | /** @var \Illuminate\Log\LogManager $instance */ |
| 7985: | return $instance->build($config); |
| 7986: | } |
| 7987: | /** |
| 7988: | * Create a new, on-demand aggregate logger instance. |
| 7989: | * |
| 7990: | * @param array $channels |
| 7991: | * @param string|null $channel |
| 7992: | * @return \Psr\Log\LoggerInterface |
| 7993: | * @static |
| 7994: | */ |
| 7995: | public static function stack($channels, $channel = null) |
| 7996: | { |
| 7997: | /** @var \Illuminate\Log\LogManager $instance */ |
| 7998: | return $instance->stack($channels, $channel); |
| 7999: | } |
| 8000: | /** |
| 8001: | * Get a log channel instance. |
| 8002: | * |
| 8003: | * @param string|null $channel |
| 8004: | * @return \Psr\Log\LoggerInterface |
| 8005: | * @static |
| 8006: | */ |
| 8007: | public static function channel($channel = null) |
| 8008: | { |
| 8009: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8010: | return $instance->channel($channel); |
| 8011: | } |
| 8012: | /** |
| 8013: | * Get a log driver instance. |
| 8014: | * |
| 8015: | * @param string|null $driver |
| 8016: | * @return \Psr\Log\LoggerInterface |
| 8017: | * @static |
| 8018: | */ |
| 8019: | public static function driver($driver = null) |
| 8020: | { |
| 8021: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8022: | return $instance->driver($driver); |
| 8023: | } |
| 8024: | /** |
| 8025: | * Share context across channels and stacks. |
| 8026: | * |
| 8027: | * @param array $context |
| 8028: | * @return \Illuminate\Log\LogManager |
| 8029: | * @static |
| 8030: | */ |
| 8031: | public static function shareContext($context) |
| 8032: | { |
| 8033: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8034: | return $instance->shareContext($context); |
| 8035: | } |
| 8036: | /** |
| 8037: | * The context shared across channels and stacks. |
| 8038: | * |
| 8039: | * @return array |
| 8040: | * @static |
| 8041: | */ |
| 8042: | public static function sharedContext() |
| 8043: | { |
| 8044: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8045: | return $instance->sharedContext(); |
| 8046: | } |
| 8047: | /** |
| 8048: | * Flush the shared context. |
| 8049: | * |
| 8050: | * @return \Illuminate\Log\LogManager |
| 8051: | * @static |
| 8052: | */ |
| 8053: | public static function flushSharedContext() |
| 8054: | { |
| 8055: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8056: | return $instance->flushSharedContext(); |
| 8057: | } |
| 8058: | /** |
| 8059: | * Get the default log driver name. |
| 8060: | * |
| 8061: | * @return string|null |
| 8062: | * @static |
| 8063: | */ |
| 8064: | public static function getDefaultDriver() |
| 8065: | { |
| 8066: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8067: | return $instance->getDefaultDriver(); |
| 8068: | } |
| 8069: | /** |
| 8070: | * Set the default log driver name. |
| 8071: | * |
| 8072: | * @param string $name |
| 8073: | * @return void |
| 8074: | * @static |
| 8075: | */ |
| 8076: | public static function setDefaultDriver($name) |
| 8077: | { |
| 8078: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8079: | $instance->setDefaultDriver($name); |
| 8080: | } |
| 8081: | /** |
| 8082: | * Register a custom driver creator Closure. |
| 8083: | * |
| 8084: | * @param string $driver |
| 8085: | * @param \Closure $callback |
| 8086: | * @return \Illuminate\Log\LogManager |
| 8087: | * @static |
| 8088: | */ |
| 8089: | public static function extend($driver, $callback) |
| 8090: | { |
| 8091: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8092: | return $instance->extend($driver, $callback); |
| 8093: | } |
| 8094: | /** |
| 8095: | * Unset the given channel instance. |
| 8096: | * |
| 8097: | * @param string|null $driver |
| 8098: | * @return \Illuminate\Log\LogManager |
| 8099: | * @static |
| 8100: | */ |
| 8101: | public static function forgetChannel($driver = null) |
| 8102: | { |
| 8103: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8104: | return $instance->forgetChannel($driver); |
| 8105: | } |
| 8106: | /** |
| 8107: | * Get all of the resolved log channels. |
| 8108: | * |
| 8109: | * @return array |
| 8110: | * @static |
| 8111: | */ |
| 8112: | public static function getChannels() |
| 8113: | { |
| 8114: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8115: | return $instance->getChannels(); |
| 8116: | } |
| 8117: | /** |
| 8118: | * System is unusable. |
| 8119: | * |
| 8120: | * @param string $message |
| 8121: | * @param array $context |
| 8122: | * @return void |
| 8123: | * @static |
| 8124: | */ |
| 8125: | public static function emergency($message, $context = []) |
| 8126: | { |
| 8127: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8128: | $instance->emergency($message, $context); |
| 8129: | } |
| 8130: | /** |
| 8131: | * Action must be taken immediately. |
| 8132: | * |
| 8133: | * Example: Entire website down, database unavailable, etc. This should |
| 8134: | * trigger the SMS alerts and wake you up. |
| 8135: | * |
| 8136: | * @param string $message |
| 8137: | * @param array $context |
| 8138: | * @return void |
| 8139: | * @static |
| 8140: | */ |
| 8141: | public static function alert($message, $context = []) |
| 8142: | { |
| 8143: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8144: | $instance->alert($message, $context); |
| 8145: | } |
| 8146: | /** |
| 8147: | * Critical conditions. |
| 8148: | * |
| 8149: | * Example: Application component unavailable, unexpected exception. |
| 8150: | * |
| 8151: | * @param string $message |
| 8152: | * @param array $context |
| 8153: | * @return void |
| 8154: | * @static |
| 8155: | */ |
| 8156: | public static function critical($message, $context = []) |
| 8157: | { |
| 8158: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8159: | $instance->critical($message, $context); |
| 8160: | } |
| 8161: | /** |
| 8162: | * Runtime errors that do not require immediate action but should typically |
| 8163: | * be logged and monitored. |
| 8164: | * |
| 8165: | * @param string $message |
| 8166: | * @param array $context |
| 8167: | * @return void |
| 8168: | * @static |
| 8169: | */ |
| 8170: | public static function error($message, $context = []) |
| 8171: | { |
| 8172: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8173: | $instance->error($message, $context); |
| 8174: | } |
| 8175: | /** |
| 8176: | * Exceptional occurrences that are not errors. |
| 8177: | * |
| 8178: | * Example: Use of deprecated APIs, poor use of an API, undesirable things |
| 8179: | * that are not necessarily wrong. |
| 8180: | * |
| 8181: | * @param string $message |
| 8182: | * @param array $context |
| 8183: | * @return void |
| 8184: | * @static |
| 8185: | */ |
| 8186: | public static function warning($message, $context = []) |
| 8187: | { |
| 8188: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8189: | $instance->warning($message, $context); |
| 8190: | } |
| 8191: | /** |
| 8192: | * Normal but significant events. |
| 8193: | * |
| 8194: | * @param string $message |
| 8195: | * @param array $context |
| 8196: | * @return void |
| 8197: | * @static |
| 8198: | */ |
| 8199: | public static function notice($message, $context = []) |
| 8200: | { |
| 8201: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8202: | $instance->notice($message, $context); |
| 8203: | } |
| 8204: | /** |
| 8205: | * Interesting events. |
| 8206: | * |
| 8207: | * Example: User logs in, SQL logs. |
| 8208: | * |
| 8209: | * @param string $message |
| 8210: | * @param array $context |
| 8211: | * @return void |
| 8212: | * @static |
| 8213: | */ |
| 8214: | public static function info($message, $context = []) |
| 8215: | { |
| 8216: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8217: | $instance->info($message, $context); |
| 8218: | } |
| 8219: | /** |
| 8220: | * Detailed debug information. |
| 8221: | * |
| 8222: | * @param string $message |
| 8223: | * @param array $context |
| 8224: | * @return void |
| 8225: | * @static |
| 8226: | */ |
| 8227: | public static function debug($message, $context = []) |
| 8228: | { |
| 8229: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8230: | $instance->debug($message, $context); |
| 8231: | } |
| 8232: | /** |
| 8233: | * Logs with an arbitrary level. |
| 8234: | * |
| 8235: | * @param mixed $level |
| 8236: | * @param string $message |
| 8237: | * @param array $context |
| 8238: | * @return void |
| 8239: | * @static |
| 8240: | */ |
| 8241: | public static function log($level, $message, $context = []) |
| 8242: | { |
| 8243: | /** @var \Illuminate\Log\LogManager $instance */ |
| 8244: | $instance->log($level, $message, $context); |
| 8245: | } |
| 8246: | |
| 8247: | } |
| 8248: | /** |
| 8249: | * |
| 8250: | * |
| 8251: | * @method static void alwaysFrom(string $address, string|null $name = null) |
| 8252: | * @method static void alwaysReplyTo(string $address, string|null $name = null) |
| 8253: | * @method static void alwaysReturnPath(string $address) |
| 8254: | * @method static void alwaysTo(string $address, string|null $name = null) |
| 8255: | * @method static \Illuminate\Mail\SentMessage|null plain(string $view, array $data, $callback) |
| 8256: | * @method static \Illuminate\Mail\SentMessage|null html(string $html, $callback) |
| 8257: | * @method static mixed laterOn(string $queue, \DateTimeInterface|\DateInterval|int $delay, \Illuminate\Contracts\Mail\Mailable|string|array $view) |
| 8258: | * @method static mixed queueOn(string $queue, \Illuminate\Contracts\Mail\Mailable|string|array $view) |
| 8259: | * @see \Illuminate\Mail\Mailer |
| 8260: | * @see \Illuminate\Support\Testing\Fakes\MailFake |
| 8261: | */ |
| 8262: | class Mail { |
| 8263: | /** |
| 8264: | * Get a mailer instance by name. |
| 8265: | * |
| 8266: | * @param string|null $name |
| 8267: | * @return \Illuminate\Contracts\Mail\Mailer |
| 8268: | * @static |
| 8269: | */ |
| 8270: | public static function mailer($name = null) |
| 8271: | { |
| 8272: | /** @var \Illuminate\Mail\MailManager $instance */ |
| 8273: | return $instance->mailer($name); |
| 8274: | } |
| 8275: | /** |
| 8276: | * Get a mailer driver instance. |
| 8277: | * |
| 8278: | * @param string|null $driver |
| 8279: | * @return \Illuminate\Mail\Mailer |
| 8280: | * @static |
| 8281: | */ |
| 8282: | public static function driver($driver = null) |
| 8283: | { |
| 8284: | /** @var \Illuminate\Mail\MailManager $instance */ |
| 8285: | return $instance->driver($driver); |
| 8286: | } |
| 8287: | /** |
| 8288: | * Create a new transport instance. |
| 8289: | * |
| 8290: | * @param array $config |
| 8291: | * @return \Symfony\Component\Mailer\Transport\TransportInterface |
| 8292: | * @throws \InvalidArgumentException |
| 8293: | * @static |
| 8294: | */ |
| 8295: | public static function createSymfonyTransport($config) |
| 8296: | { |
| 8297: | /** @var \Illuminate\Mail\MailManager $instance */ |
| 8298: | return $instance->createSymfonyTransport($config); |
| 8299: | } |
| 8300: | /** |
| 8301: | * Get the default mail driver name. |
| 8302: | * |
| 8303: | * @return string |
| 8304: | * @static |
| 8305: | */ |
| 8306: | public static function getDefaultDriver() |
| 8307: | { |
| 8308: | /** @var \Illuminate\Mail\MailManager $instance */ |
| 8309: | return $instance->getDefaultDriver(); |
| 8310: | } |
| 8311: | /** |
| 8312: | * Set the default mail driver name. |
| 8313: | * |
| 8314: | * @param string $name |
| 8315: | * @return void |
| 8316: | * @static |
| 8317: | */ |
| 8318: | public static function setDefaultDriver($name) |
| 8319: | { |
| 8320: | /** @var \Illuminate\Mail\MailManager $instance */ |
| 8321: | $instance->setDefaultDriver($name); |
| 8322: | } |
| 8323: | /** |
| 8324: | * Disconnect the given mailer and remove from local cache. |
| 8325: | * |
| 8326: | * @param string|null $name |
| 8327: | * @return void |
| 8328: | * @static |
| 8329: | */ |
| 8330: | public static function purge($name = null) |
| 8331: | { |
| 8332: | /** @var \Illuminate\Mail\MailManager $instance */ |
| 8333: | $instance->purge($name); |
| 8334: | } |
| 8335: | /** |
| 8336: | * Register a custom transport creator Closure. |
| 8337: | * |
| 8338: | * @param string $driver |
| 8339: | * @param \Closure $callback |
| 8340: | * @return \Illuminate\Mail\MailManager |
| 8341: | * @static |
| 8342: | */ |
| 8343: | public static function extend($driver, $callback) |
| 8344: | { |
| 8345: | /** @var \Illuminate\Mail\MailManager $instance */ |
| 8346: | return $instance->extend($driver, $callback); |
| 8347: | } |
| 8348: | /** |
| 8349: | * Get the application instance used by the manager. |
| 8350: | * |
| 8351: | * @return \Illuminate\Contracts\Foundation\Application |
| 8352: | * @static |
| 8353: | */ |
| 8354: | public static function getApplication() |
| 8355: | { |
| 8356: | /** @var \Illuminate\Mail\MailManager $instance */ |
| 8357: | return $instance->getApplication(); |
| 8358: | } |
| 8359: | /** |
| 8360: | * Set the application instance used by the manager. |
| 8361: | * |
| 8362: | * @param \Illuminate\Contracts\Foundation\Application $app |
| 8363: | * @return \Illuminate\Mail\MailManager |
| 8364: | * @static |
| 8365: | */ |
| 8366: | public static function setApplication($app) |
| 8367: | { |
| 8368: | /** @var \Illuminate\Mail\MailManager $instance */ |
| 8369: | return $instance->setApplication($app); |
| 8370: | } |
| 8371: | /** |
| 8372: | * Forget all of the resolved mailer instances. |
| 8373: | * |
| 8374: | * @return \Illuminate\Mail\MailManager |
| 8375: | * @static |
| 8376: | */ |
| 8377: | public static function forgetMailers() |
| 8378: | { |
| 8379: | /** @var \Illuminate\Mail\MailManager $instance */ |
| 8380: | return $instance->forgetMailers(); |
| 8381: | } |
| 8382: | /** |
| 8383: | * Assert if a mailable was sent based on a truth-test callback. |
| 8384: | * |
| 8385: | * @param string|\Closure $mailable |
| 8386: | * @param callable|int|null $callback |
| 8387: | * @return void |
| 8388: | * @static |
| 8389: | */ |
| 8390: | public static function assertSent($mailable, $callback = null) |
| 8391: | { |
| 8392: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8393: | $instance->assertSent($mailable, $callback); |
| 8394: | } |
| 8395: | /** |
| 8396: | * Determine if a mailable was not sent or queued to be sent based on a truth-test callback. |
| 8397: | * |
| 8398: | * @param string|\Closure $mailable |
| 8399: | * @param callable|null $callback |
| 8400: | * @return void |
| 8401: | * @static |
| 8402: | */ |
| 8403: | public static function assertNotOutgoing($mailable, $callback = null) |
| 8404: | { |
| 8405: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8406: | $instance->assertNotOutgoing($mailable, $callback); |
| 8407: | } |
| 8408: | /** |
| 8409: | * Determine if a mailable was not sent based on a truth-test callback. |
| 8410: | * |
| 8411: | * @param string|\Closure $mailable |
| 8412: | * @param callable|null $callback |
| 8413: | * @return void |
| 8414: | * @static |
| 8415: | */ |
| 8416: | public static function assertNotSent($mailable, $callback = null) |
| 8417: | { |
| 8418: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8419: | $instance->assertNotSent($mailable, $callback); |
| 8420: | } |
| 8421: | /** |
| 8422: | * Assert that no mailables were sent or queued to be sent. |
| 8423: | * |
| 8424: | * @return void |
| 8425: | * @static |
| 8426: | */ |
| 8427: | public static function assertNothingOutgoing() |
| 8428: | { |
| 8429: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8430: | $instance->assertNothingOutgoing(); |
| 8431: | } |
| 8432: | /** |
| 8433: | * Assert that no mailables were sent. |
| 8434: | * |
| 8435: | * @return void |
| 8436: | * @static |
| 8437: | */ |
| 8438: | public static function assertNothingSent() |
| 8439: | { |
| 8440: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8441: | $instance->assertNothingSent(); |
| 8442: | } |
| 8443: | /** |
| 8444: | * Assert if a mailable was queued based on a truth-test callback. |
| 8445: | * |
| 8446: | * @param string|\Closure $mailable |
| 8447: | * @param callable|int|null $callback |
| 8448: | * @return void |
| 8449: | * @static |
| 8450: | */ |
| 8451: | public static function assertQueued($mailable, $callback = null) |
| 8452: | { |
| 8453: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8454: | $instance->assertQueued($mailable, $callback); |
| 8455: | } |
| 8456: | /** |
| 8457: | * Determine if a mailable was not queued based on a truth-test callback. |
| 8458: | * |
| 8459: | * @param string|\Closure $mailable |
| 8460: | * @param callable|null $callback |
| 8461: | * @return void |
| 8462: | * @static |
| 8463: | */ |
| 8464: | public static function assertNotQueued($mailable, $callback = null) |
| 8465: | { |
| 8466: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8467: | $instance->assertNotQueued($mailable, $callback); |
| 8468: | } |
| 8469: | /** |
| 8470: | * Assert that no mailables were queued. |
| 8471: | * |
| 8472: | * @return void |
| 8473: | * @static |
| 8474: | */ |
| 8475: | public static function assertNothingQueued() |
| 8476: | { |
| 8477: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8478: | $instance->assertNothingQueued(); |
| 8479: | } |
| 8480: | /** |
| 8481: | * Get all of the mailables matching a truth-test callback. |
| 8482: | * |
| 8483: | * @param string|\Closure $mailable |
| 8484: | * @param callable|null $callback |
| 8485: | * @return \Illuminate\Support\Collection |
| 8486: | * @static |
| 8487: | */ |
| 8488: | public static function sent($mailable, $callback = null) |
| 8489: | { |
| 8490: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8491: | return $instance->sent($mailable, $callback); |
| 8492: | } |
| 8493: | /** |
| 8494: | * Determine if the given mailable has been sent. |
| 8495: | * |
| 8496: | * @param string $mailable |
| 8497: | * @return bool |
| 8498: | * @static |
| 8499: | */ |
| 8500: | public static function hasSent($mailable) |
| 8501: | { |
| 8502: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8503: | return $instance->hasSent($mailable); |
| 8504: | } |
| 8505: | /** |
| 8506: | * Get all of the queued mailables matching a truth-test callback. |
| 8507: | * |
| 8508: | * @param string|\Closure $mailable |
| 8509: | * @param callable|null $callback |
| 8510: | * @return \Illuminate\Support\Collection |
| 8511: | * @static |
| 8512: | */ |
| 8513: | public static function queued($mailable, $callback = null) |
| 8514: | { |
| 8515: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8516: | return $instance->queued($mailable, $callback); |
| 8517: | } |
| 8518: | /** |
| 8519: | * Determine if the given mailable has been queued. |
| 8520: | * |
| 8521: | * @param string $mailable |
| 8522: | * @return bool |
| 8523: | * @static |
| 8524: | */ |
| 8525: | public static function hasQueued($mailable) |
| 8526: | { |
| 8527: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8528: | return $instance->hasQueued($mailable); |
| 8529: | } |
| 8530: | /** |
| 8531: | * Begin the process of mailing a mailable class instance. |
| 8532: | * |
| 8533: | * @param mixed $users |
| 8534: | * @return \Illuminate\Mail\PendingMail |
| 8535: | * @static |
| 8536: | */ |
| 8537: | public static function to($users) |
| 8538: | { |
| 8539: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8540: | return $instance->to($users); |
| 8541: | } |
| 8542: | /** |
| 8543: | * Begin the process of mailing a mailable class instance. |
| 8544: | * |
| 8545: | * @param mixed $users |
| 8546: | * @return \Illuminate\Mail\PendingMail |
| 8547: | * @static |
| 8548: | */ |
| 8549: | public static function bcc($users) |
| 8550: | { |
| 8551: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8552: | return $instance->bcc($users); |
| 8553: | } |
| 8554: | /** |
| 8555: | * Send a new message with only a raw text part. |
| 8556: | * |
| 8557: | * @param string $text |
| 8558: | * @param \Closure|string $callback |
| 8559: | * @return void |
| 8560: | * @static |
| 8561: | */ |
| 8562: | public static function raw($text, $callback) |
| 8563: | { |
| 8564: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8565: | $instance->raw($text, $callback); |
| 8566: | } |
| 8567: | /** |
| 8568: | * Send a new message using a view. |
| 8569: | * |
| 8570: | * @param \Illuminate\Contracts\Mail\Mailable|string|array $view |
| 8571: | * @param array $data |
| 8572: | * @param \Closure|string|null $callback |
| 8573: | * @return void |
| 8574: | * @static |
| 8575: | */ |
| 8576: | public static function send($view, $data = [], $callback = null) |
| 8577: | { |
| 8578: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8579: | $instance->send($view, $data, $callback); |
| 8580: | } |
| 8581: | /** |
| 8582: | * Queue a new e-mail message for sending. |
| 8583: | * |
| 8584: | * @param \Illuminate\Contracts\Mail\Mailable|string|array $view |
| 8585: | * @param string|null $queue |
| 8586: | * @return mixed |
| 8587: | * @static |
| 8588: | */ |
| 8589: | public static function queue($view, $queue = null) |
| 8590: | { |
| 8591: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8592: | return $instance->queue($view, $queue); |
| 8593: | } |
| 8594: | /** |
| 8595: | * Queue a new e-mail message for sending after (n) seconds. |
| 8596: | * |
| 8597: | * @param \DateTimeInterface|\DateInterval|int $delay |
| 8598: | * @param \Illuminate\Contracts\Mail\Mailable|string|array $view |
| 8599: | * @param string|null $queue |
| 8600: | * @return mixed |
| 8601: | * @static |
| 8602: | */ |
| 8603: | public static function later($delay, $view, $queue = null) |
| 8604: | { |
| 8605: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8606: | return $instance->later($delay, $view, $queue); |
| 8607: | } |
| 8608: | /** |
| 8609: | * Get the array of failed recipients. |
| 8610: | * |
| 8611: | * @return array |
| 8612: | * @static |
| 8613: | */ |
| 8614: | public static function failures() |
| 8615: | { |
| 8616: | /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */ |
| 8617: | return $instance->failures(); |
| 8618: | } |
| 8619: | |
| 8620: | } |
| 8621: | /** |
| 8622: | * |
| 8623: | * |
| 8624: | * @see \Illuminate\Notifications\ChannelManager |
| 8625: | */ |
| 8626: | class Notification { |
| 8627: | /** |
| 8628: | * Send the given notification to the given notifiable entities. |
| 8629: | * |
| 8630: | * @param \Illuminate\Support\Collection|array|mixed $notifiables |
| 8631: | * @param mixed $notification |
| 8632: | * @return void |
| 8633: | * @static |
| 8634: | */ |
| 8635: | public static function send($notifiables, $notification) |
| 8636: | { |
| 8637: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8638: | $instance->send($notifiables, $notification); |
| 8639: | } |
| 8640: | /** |
| 8641: | * Send the given notification immediately. |
| 8642: | * |
| 8643: | * @param \Illuminate\Support\Collection|array|mixed $notifiables |
| 8644: | * @param mixed $notification |
| 8645: | * @param array|null $channels |
| 8646: | * @return void |
| 8647: | * @static |
| 8648: | */ |
| 8649: | public static function sendNow($notifiables, $notification, $channels = null) |
| 8650: | { |
| 8651: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8652: | $instance->sendNow($notifiables, $notification, $channels); |
| 8653: | } |
| 8654: | /** |
| 8655: | * Get a channel instance. |
| 8656: | * |
| 8657: | * @param string|null $name |
| 8658: | * @return mixed |
| 8659: | * @static |
| 8660: | */ |
| 8661: | public static function channel($name = null) |
| 8662: | { |
| 8663: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8664: | return $instance->channel($name); |
| 8665: | } |
| 8666: | /** |
| 8667: | * Get the default channel driver name. |
| 8668: | * |
| 8669: | * @return string |
| 8670: | * @static |
| 8671: | */ |
| 8672: | public static function getDefaultDriver() |
| 8673: | { |
| 8674: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8675: | return $instance->getDefaultDriver(); |
| 8676: | } |
| 8677: | /** |
| 8678: | * Get the default channel driver name. |
| 8679: | * |
| 8680: | * @return string |
| 8681: | * @static |
| 8682: | */ |
| 8683: | public static function deliversVia() |
| 8684: | { |
| 8685: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8686: | return $instance->deliversVia(); |
| 8687: | } |
| 8688: | /** |
| 8689: | * Set the default channel driver name. |
| 8690: | * |
| 8691: | * @param string $channel |
| 8692: | * @return void |
| 8693: | * @static |
| 8694: | */ |
| 8695: | public static function deliverVia($channel) |
| 8696: | { |
| 8697: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8698: | $instance->deliverVia($channel); |
| 8699: | } |
| 8700: | /** |
| 8701: | * Set the locale of notifications. |
| 8702: | * |
| 8703: | * @param string $locale |
| 8704: | * @return \Illuminate\Notifications\ChannelManager |
| 8705: | * @static |
| 8706: | */ |
| 8707: | public static function locale($locale) |
| 8708: | { |
| 8709: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8710: | return $instance->locale($locale); |
| 8711: | } |
| 8712: | /** |
| 8713: | * Get a driver instance. |
| 8714: | * |
| 8715: | * @param string|null $driver |
| 8716: | * @return mixed |
| 8717: | * @throws \InvalidArgumentException |
| 8718: | * @static |
| 8719: | */ |
| 8720: | public static function driver($driver = null) |
| 8721: | { //Method inherited from \Illuminate\Support\Manager |
| 8722: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8723: | return $instance->driver($driver); |
| 8724: | } |
| 8725: | /** |
| 8726: | * Register a custom driver creator Closure. |
| 8727: | * |
| 8728: | * @param string $driver |
| 8729: | * @param \Closure $callback |
| 8730: | * @return \Illuminate\Notifications\ChannelManager |
| 8731: | * @static |
| 8732: | */ |
| 8733: | public static function extend($driver, $callback) |
| 8734: | { //Method inherited from \Illuminate\Support\Manager |
| 8735: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8736: | return $instance->extend($driver, $callback); |
| 8737: | } |
| 8738: | /** |
| 8739: | * Get all of the created "drivers". |
| 8740: | * |
| 8741: | * @return array |
| 8742: | * @static |
| 8743: | */ |
| 8744: | public static function getDrivers() |
| 8745: | { //Method inherited from \Illuminate\Support\Manager |
| 8746: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8747: | return $instance->getDrivers(); |
| 8748: | } |
| 8749: | /** |
| 8750: | * Get the container instance used by the manager. |
| 8751: | * |
| 8752: | * @return \Illuminate\Contracts\Container\Container |
| 8753: | * @static |
| 8754: | */ |
| 8755: | public static function getContainer() |
| 8756: | { //Method inherited from \Illuminate\Support\Manager |
| 8757: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8758: | return $instance->getContainer(); |
| 8759: | } |
| 8760: | /** |
| 8761: | * Set the container instance used by the manager. |
| 8762: | * |
| 8763: | * @param \Illuminate\Contracts\Container\Container $container |
| 8764: | * @return \Illuminate\Notifications\ChannelManager |
| 8765: | * @static |
| 8766: | */ |
| 8767: | public static function setContainer($container) |
| 8768: | { //Method inherited from \Illuminate\Support\Manager |
| 8769: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8770: | return $instance->setContainer($container); |
| 8771: | } |
| 8772: | /** |
| 8773: | * Forget all of the resolved driver instances. |
| 8774: | * |
| 8775: | * @return \Illuminate\Notifications\ChannelManager |
| 8776: | * @static |
| 8777: | */ |
| 8778: | public static function forgetDrivers() |
| 8779: | { //Method inherited from \Illuminate\Support\Manager |
| 8780: | /** @var \Illuminate\Notifications\ChannelManager $instance */ |
| 8781: | return $instance->forgetDrivers(); |
| 8782: | } |
| 8783: | /** |
| 8784: | * Assert if a notification was sent on-demand based on a truth-test callback. |
| 8785: | * |
| 8786: | * @param string|\Closure $notification |
| 8787: | * @param callable|null $callback |
| 8788: | * @return void |
| 8789: | * @throws \Exception |
| 8790: | * @static |
| 8791: | */ |
| 8792: | public static function assertSentOnDemand($notification, $callback = null) |
| 8793: | { |
| 8794: | /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */ |
| 8795: | $instance->assertSentOnDemand($notification, $callback); |
| 8796: | } |
| 8797: | /** |
| 8798: | * Assert if a notification was sent based on a truth-test callback. |
| 8799: | * |
| 8800: | * @param mixed $notifiable |
| 8801: | * @param string|\Closure $notification |
| 8802: | * @param callable|null $callback |
| 8803: | * @return void |
| 8804: | * @throws \Exception |
| 8805: | * @static |
| 8806: | */ |
| 8807: | public static function assertSentTo($notifiable, $notification, $callback = null) |
| 8808: | { |
| 8809: | /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */ |
| 8810: | $instance->assertSentTo($notifiable, $notification, $callback); |
| 8811: | } |
| 8812: | /** |
| 8813: | * Assert if a notification was sent on-demand a number of times. |
| 8814: | * |
| 8815: | * @param string $notification |
| 8816: | * @param int $times |
| 8817: | * @return void |
| 8818: | * @static |
| 8819: | */ |
| 8820: | public static function assertSentOnDemandTimes($notification, $times = 1) |
| 8821: | { |
| 8822: | /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */ |
| 8823: | $instance->assertSentOnDemandTimes($notification, $times); |
| 8824: | } |
| 8825: | /** |
| 8826: | * Assert if a notification was sent a number of times. |
| 8827: | * |
| 8828: | * @param mixed $notifiable |
| 8829: | * @param string $notification |
| 8830: | * @param int $times |
| 8831: | * @return void |
| 8832: | * @static |
| 8833: | */ |
| 8834: | public static function assertSentToTimes($notifiable, $notification, $times = 1) |
| 8835: | { |
| 8836: | /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */ |
| 8837: | $instance->assertSentToTimes($notifiable, $notification, $times); |
| 8838: | } |
| 8839: | /** |
| 8840: | * Determine if a notification was sent based on a truth-test callback. |
| 8841: | * |
| 8842: | * @param mixed $notifiable |
| 8843: | * @param string|\Closure $notification |
| 8844: | * @param callable|null $callback |
| 8845: | * @return void |
| 8846: | * @throws \Exception |
| 8847: | * @static |
| 8848: | */ |
| 8849: | public static function assertNotSentTo($notifiable, $notification, $callback = null) |
| 8850: | { |
| 8851: | /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */ |
| 8852: | $instance->assertNotSentTo($notifiable, $notification, $callback); |
| 8853: | } |
| 8854: | /** |
| 8855: | * Assert that no notifications were sent. |
| 8856: | * |
| 8857: | * @return void |
| 8858: | * @static |
| 8859: | */ |
| 8860: | public static function assertNothingSent() |
| 8861: | { |
| 8862: | /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */ |
| 8863: | $instance->assertNothingSent(); |
| 8864: | } |
| 8865: | /** |
| 8866: | * Assert that no notifications were sent to the given notifiable. |
| 8867: | * |
| 8868: | * @param mixed $notifiable |
| 8869: | * @return void |
| 8870: | * @throws \Exception |
| 8871: | * @static |
| 8872: | */ |
| 8873: | public static function assertNothingSentTo($notifiable) |
| 8874: | { |
| 8875: | /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */ |
| 8876: | $instance->assertNothingSentTo($notifiable); |
| 8877: | } |
| 8878: | /** |
| 8879: | * Assert the total amount of times a notification was sent. |
| 8880: | * |
| 8881: | * @param string $notification |
| 8882: | * @param int $expectedCount |
| 8883: | * @return void |
| 8884: | * @static |
| 8885: | */ |
| 8886: | public static function assertSentTimes($notification, $expectedCount) |
| 8887: | { |
| 8888: | /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */ |
| 8889: | $instance->assertSentTimes($notification, $expectedCount); |
| 8890: | } |
| 8891: | /** |
| 8892: | * Assert the total count of notification that were sent. |
| 8893: | * |
| 8894: | * @param int $expectedCount |
| 8895: | * @return void |
| 8896: | * @static |
| 8897: | */ |
| 8898: | public static function assertCount($expectedCount) |
| 8899: | { |
| 8900: | /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */ |
| 8901: | $instance->assertCount($expectedCount); |
| 8902: | } |
| 8903: | /** |
| 8904: | * Assert the total amount of times a notification was sent. |
| 8905: | * |
| 8906: | * @param int $expectedCount |
| 8907: | * @param string $notification |
| 8908: | * @return void |
| 8909: | * @deprecated Use the assertSentTimes method instead |
| 8910: | * @static |
| 8911: | */ |
| 8912: | public static function assertTimesSent($expectedCount, $notification) |
| 8913: | { |
| 8914: | /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */ |
| 8915: | $instance->assertTimesSent($expectedCount, $notification); |
| 8916: | } |
| 8917: | /** |
| 8918: | * Get all of the notifications matching a truth-test callback. |
| 8919: | * |
| 8920: | * @param mixed $notifiable |
| 8921: | * @param string $notification |
| 8922: | * @param callable|null $callback |
| 8923: | * @return \Illuminate\Support\Collection |
| 8924: | * @static |
| 8925: | */ |
| 8926: | public static function sent($notifiable, $notification, $callback = null) |
| 8927: | { |
| 8928: | /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */ |
| 8929: | return $instance->sent($notifiable, $notification, $callback); |
| 8930: | } |
| 8931: | /** |
| 8932: | * Determine if there are more notifications left to inspect. |
| 8933: | * |
| 8934: | * @param mixed $notifiable |
| 8935: | * @param string $notification |
| 8936: | * @return bool |
| 8937: | * @static |
| 8938: | */ |
| 8939: | public static function hasSent($notifiable, $notification) |
| 8940: | { |
| 8941: | /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */ |
| 8942: | return $instance->hasSent($notifiable, $notification); |
| 8943: | } |
| 8944: | /** |
| 8945: | * Register a custom macro. |
| 8946: | * |
| 8947: | * @param string $name |
| 8948: | * @param object|callable $macro |
| 8949: | * @return void |
| 8950: | * @static |
| 8951: | */ |
| 8952: | public static function macro($name, $macro) |
| 8953: | { |
| 8954: | \Illuminate\Support\Testing\Fakes\NotificationFake::macro($name, $macro); |
| 8955: | } |
| 8956: | /** |
| 8957: | * Mix another object into the class. |
| 8958: | * |
| 8959: | * @param object $mixin |
| 8960: | * @param bool $replace |
| 8961: | * @return void |
| 8962: | * @throws \ReflectionException |
| 8963: | * @static |
| 8964: | */ |
| 8965: | public static function mixin($mixin, $replace = true) |
| 8966: | { |
| 8967: | \Illuminate\Support\Testing\Fakes\NotificationFake::mixin($mixin, $replace); |
| 8968: | } |
| 8969: | /** |
| 8970: | * Checks if macro is registered. |
| 8971: | * |
| 8972: | * @param string $name |
| 8973: | * @return bool |
| 8974: | * @static |
| 8975: | */ |
| 8976: | public static function hasMacro($name) |
| 8977: | { |
| 8978: | return \Illuminate\Support\Testing\Fakes\NotificationFake::hasMacro($name); |
| 8979: | } |
| 8980: | /** |
| 8981: | * Flush the existing macros. |
| 8982: | * |
| 8983: | * @return void |
| 8984: | * @static |
| 8985: | */ |
| 8986: | public static function flushMacros() |
| 8987: | { |
| 8988: | \Illuminate\Support\Testing\Fakes\NotificationFake::flushMacros(); |
| 8989: | } |
| 8990: | |
| 8991: | } |
| 8992: | /** |
| 8993: | * |
| 8994: | * |
| 8995: | * @method static mixed reset(array $credentials, \Closure $callback) |
| 8996: | * @method static string sendResetLink(array $credentials, \Closure $callback = null) |
| 8997: | * @method static \Illuminate\Contracts\Auth\CanResetPassword getUser(array $credentials) |
| 8998: | * @method static string createToken(\Illuminate\Contracts\Auth\CanResetPassword $user) |
| 8999: | * @method static void deleteToken(\Illuminate\Contracts\Auth\CanResetPassword $user) |
| 9000: | * @method static bool tokenExists(\Illuminate\Contracts\Auth\CanResetPassword $user, string $token) |
| 9001: | * @method static \Illuminate\Auth\Passwords\TokenRepositoryInterface getRepository() |
| 9002: | * @see \Illuminate\Auth\Passwords\PasswordBroker |
| 9003: | */ |
| 9004: | class Password { |
| 9005: | /** |
| 9006: | * Attempt to get the broker from the local cache. |
| 9007: | * |
| 9008: | * @param string|null $name |
| 9009: | * @return \Illuminate\Contracts\Auth\PasswordBroker |
| 9010: | * @static |
| 9011: | */ |
| 9012: | public static function broker($name = null) |
| 9013: | { |
| 9014: | /** @var \Illuminate\Auth\Passwords\PasswordBrokerManager $instance */ |
| 9015: | return $instance->broker($name); |
| 9016: | } |
| 9017: | /** |
| 9018: | * Get the default password broker name. |
| 9019: | * |
| 9020: | * @return string |
| 9021: | * @static |
| 9022: | */ |
| 9023: | public static function getDefaultDriver() |
| 9024: | { |
| 9025: | /** @var \Illuminate\Auth\Passwords\PasswordBrokerManager $instance */ |
| 9026: | return $instance->getDefaultDriver(); |
| 9027: | } |
| 9028: | /** |
| 9029: | * Set the default password broker name. |
| 9030: | * |
| 9031: | * @param string $name |
| 9032: | * @return void |
| 9033: | * @static |
| 9034: | */ |
| 9035: | public static function setDefaultDriver($name) |
| 9036: | { |
| 9037: | /** @var \Illuminate\Auth\Passwords\PasswordBrokerManager $instance */ |
| 9038: | $instance->setDefaultDriver($name); |
| 9039: | } |
| 9040: | |
| 9041: | } |
| 9042: | /** |
| 9043: | * |
| 9044: | * |
| 9045: | * @see \Illuminate\Queue\QueueManager |
| 9046: | * @see \Illuminate\Queue\Queue |
| 9047: | */ |
| 9048: | class Queue { |
| 9049: | /** |
| 9050: | * Register an event listener for the before job event. |
| 9051: | * |
| 9052: | * @param mixed $callback |
| 9053: | * @return void |
| 9054: | * @static |
| 9055: | */ |
| 9056: | public static function before($callback) |
| 9057: | { |
| 9058: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9059: | $instance->before($callback); |
| 9060: | } |
| 9061: | /** |
| 9062: | * Register an event listener for the after job event. |
| 9063: | * |
| 9064: | * @param mixed $callback |
| 9065: | * @return void |
| 9066: | * @static |
| 9067: | */ |
| 9068: | public static function after($callback) |
| 9069: | { |
| 9070: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9071: | $instance->after($callback); |
| 9072: | } |
| 9073: | /** |
| 9074: | * Register an event listener for the exception occurred job event. |
| 9075: | * |
| 9076: | * @param mixed $callback |
| 9077: | * @return void |
| 9078: | * @static |
| 9079: | */ |
| 9080: | public static function exceptionOccurred($callback) |
| 9081: | { |
| 9082: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9083: | $instance->exceptionOccurred($callback); |
| 9084: | } |
| 9085: | /** |
| 9086: | * Register an event listener for the daemon queue loop. |
| 9087: | * |
| 9088: | * @param mixed $callback |
| 9089: | * @return void |
| 9090: | * @static |
| 9091: | */ |
| 9092: | public static function looping($callback) |
| 9093: | { |
| 9094: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9095: | $instance->looping($callback); |
| 9096: | } |
| 9097: | /** |
| 9098: | * Register an event listener for the failed job event. |
| 9099: | * |
| 9100: | * @param mixed $callback |
| 9101: | * @return void |
| 9102: | * @static |
| 9103: | */ |
| 9104: | public static function failing($callback) |
| 9105: | { |
| 9106: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9107: | $instance->failing($callback); |
| 9108: | } |
| 9109: | /** |
| 9110: | * Register an event listener for the daemon queue stopping. |
| 9111: | * |
| 9112: | * @param mixed $callback |
| 9113: | * @return void |
| 9114: | * @static |
| 9115: | */ |
| 9116: | public static function stopping($callback) |
| 9117: | { |
| 9118: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9119: | $instance->stopping($callback); |
| 9120: | } |
| 9121: | /** |
| 9122: | * Determine if the driver is connected. |
| 9123: | * |
| 9124: | * @param string|null $name |
| 9125: | * @return bool |
| 9126: | * @static |
| 9127: | */ |
| 9128: | public static function connected($name = null) |
| 9129: | { |
| 9130: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9131: | return $instance->connected($name); |
| 9132: | } |
| 9133: | /** |
| 9134: | * Resolve a queue connection instance. |
| 9135: | * |
| 9136: | * @param string|null $name |
| 9137: | * @return \Illuminate\Contracts\Queue\Queue |
| 9138: | * @static |
| 9139: | */ |
| 9140: | public static function connection($name = null) |
| 9141: | { |
| 9142: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9143: | return $instance->connection($name); |
| 9144: | } |
| 9145: | /** |
| 9146: | * Add a queue connection resolver. |
| 9147: | * |
| 9148: | * @param string $driver |
| 9149: | * @param \Closure $resolver |
| 9150: | * @return void |
| 9151: | * @static |
| 9152: | */ |
| 9153: | public static function extend($driver, $resolver) |
| 9154: | { |
| 9155: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9156: | $instance->extend($driver, $resolver); |
| 9157: | } |
| 9158: | /** |
| 9159: | * Add a queue connection resolver. |
| 9160: | * |
| 9161: | * @param string $driver |
| 9162: | * @param \Closure $resolver |
| 9163: | * @return void |
| 9164: | * @static |
| 9165: | */ |
| 9166: | public static function addConnector($driver, $resolver) |
| 9167: | { |
| 9168: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9169: | $instance->addConnector($driver, $resolver); |
| 9170: | } |
| 9171: | /** |
| 9172: | * Get the name of the default queue connection. |
| 9173: | * |
| 9174: | * @return string |
| 9175: | * @static |
| 9176: | */ |
| 9177: | public static function getDefaultDriver() |
| 9178: | { |
| 9179: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9180: | return $instance->getDefaultDriver(); |
| 9181: | } |
| 9182: | /** |
| 9183: | * Set the name of the default queue connection. |
| 9184: | * |
| 9185: | * @param string $name |
| 9186: | * @return void |
| 9187: | * @static |
| 9188: | */ |
| 9189: | public static function setDefaultDriver($name) |
| 9190: | { |
| 9191: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9192: | $instance->setDefaultDriver($name); |
| 9193: | } |
| 9194: | /** |
| 9195: | * Get the full name for the given connection. |
| 9196: | * |
| 9197: | * @param string|null $connection |
| 9198: | * @return string |
| 9199: | * @static |
| 9200: | */ |
| 9201: | public static function getName($connection = null) |
| 9202: | { |
| 9203: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9204: | return $instance->getName($connection); |
| 9205: | } |
| 9206: | /** |
| 9207: | * Get the application instance used by the manager. |
| 9208: | * |
| 9209: | * @return \Illuminate\Contracts\Foundation\Application |
| 9210: | * @static |
| 9211: | */ |
| 9212: | public static function getApplication() |
| 9213: | { |
| 9214: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9215: | return $instance->getApplication(); |
| 9216: | } |
| 9217: | /** |
| 9218: | * Set the application instance used by the manager. |
| 9219: | * |
| 9220: | * @param \Illuminate\Contracts\Foundation\Application $app |
| 9221: | * @return \Illuminate\Queue\QueueManager |
| 9222: | * @static |
| 9223: | */ |
| 9224: | public static function setApplication($app) |
| 9225: | { |
| 9226: | /** @var \Illuminate\Queue\QueueManager $instance */ |
| 9227: | return $instance->setApplication($app); |
| 9228: | } |
| 9229: | /** |
| 9230: | * Assert if a job was pushed based on a truth-test callback. |
| 9231: | * |
| 9232: | * @param string|\Closure $job |
| 9233: | * @param callable|int|null $callback |
| 9234: | * @return void |
| 9235: | * @static |
| 9236: | */ |
| 9237: | public static function assertPushed($job, $callback = null) |
| 9238: | { |
| 9239: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9240: | $instance->assertPushed($job, $callback); |
| 9241: | } |
| 9242: | /** |
| 9243: | * Assert if a job was pushed based on a truth-test callback. |
| 9244: | * |
| 9245: | * @param string $queue |
| 9246: | * @param string|\Closure $job |
| 9247: | * @param callable|null $callback |
| 9248: | * @return void |
| 9249: | * @static |
| 9250: | */ |
| 9251: | public static function assertPushedOn($queue, $job, $callback = null) |
| 9252: | { |
| 9253: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9254: | $instance->assertPushedOn($queue, $job, $callback); |
| 9255: | } |
| 9256: | /** |
| 9257: | * Assert if a job was pushed with chained jobs based on a truth-test callback. |
| 9258: | * |
| 9259: | * @param string $job |
| 9260: | * @param array $expectedChain |
| 9261: | * @param callable|null $callback |
| 9262: | * @return void |
| 9263: | * @static |
| 9264: | */ |
| 9265: | public static function assertPushedWithChain($job, $expectedChain = [], $callback = null) |
| 9266: | { |
| 9267: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9268: | $instance->assertPushedWithChain($job, $expectedChain, $callback); |
| 9269: | } |
| 9270: | /** |
| 9271: | * Assert if a job was pushed with an empty chain based on a truth-test callback. |
| 9272: | * |
| 9273: | * @param string $job |
| 9274: | * @param callable|null $callback |
| 9275: | * @return void |
| 9276: | * @static |
| 9277: | */ |
| 9278: | public static function assertPushedWithoutChain($job, $callback = null) |
| 9279: | { |
| 9280: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9281: | $instance->assertPushedWithoutChain($job, $callback); |
| 9282: | } |
| 9283: | /** |
| 9284: | * Determine if a job was pushed based on a truth-test callback. |
| 9285: | * |
| 9286: | * @param string|\Closure $job |
| 9287: | * @param callable|null $callback |
| 9288: | * @return void |
| 9289: | * @static |
| 9290: | */ |
| 9291: | public static function assertNotPushed($job, $callback = null) |
| 9292: | { |
| 9293: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9294: | $instance->assertNotPushed($job, $callback); |
| 9295: | } |
| 9296: | /** |
| 9297: | * Assert that no jobs were pushed. |
| 9298: | * |
| 9299: | * @return void |
| 9300: | * @static |
| 9301: | */ |
| 9302: | public static function assertNothingPushed() |
| 9303: | { |
| 9304: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9305: | $instance->assertNothingPushed(); |
| 9306: | } |
| 9307: | /** |
| 9308: | * Get all of the jobs matching a truth-test callback. |
| 9309: | * |
| 9310: | * @param string $job |
| 9311: | * @param callable|null $callback |
| 9312: | * @return \Illuminate\Support\Collection |
| 9313: | * @static |
| 9314: | */ |
| 9315: | public static function pushed($job, $callback = null) |
| 9316: | { |
| 9317: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9318: | return $instance->pushed($job, $callback); |
| 9319: | } |
| 9320: | /** |
| 9321: | * Determine if there are any stored jobs for a given class. |
| 9322: | * |
| 9323: | * @param string $job |
| 9324: | * @return bool |
| 9325: | * @static |
| 9326: | */ |
| 9327: | public static function hasPushed($job) |
| 9328: | { |
| 9329: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9330: | return $instance->hasPushed($job); |
| 9331: | } |
| 9332: | /** |
| 9333: | * Get the size of the queue. |
| 9334: | * |
| 9335: | * @param string|null $queue |
| 9336: | * @return int |
| 9337: | * @static |
| 9338: | */ |
| 9339: | public static function size($queue = null) |
| 9340: | { |
| 9341: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9342: | return $instance->size($queue); |
| 9343: | } |
| 9344: | /** |
| 9345: | * Push a new job onto the queue. |
| 9346: | * |
| 9347: | * @param string|object $job |
| 9348: | * @param mixed $data |
| 9349: | * @param string|null $queue |
| 9350: | * @return mixed |
| 9351: | * @static |
| 9352: | */ |
| 9353: | public static function push($job, $data = '', $queue = null) |
| 9354: | { |
| 9355: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9356: | return $instance->push($job, $data, $queue); |
| 9357: | } |
| 9358: | /** |
| 9359: | * Determine if a job should be faked or actually dispatched. |
| 9360: | * |
| 9361: | * @param object $job |
| 9362: | * @return bool |
| 9363: | * @static |
| 9364: | */ |
| 9365: | public static function shouldFakeJob($job) |
| 9366: | { |
| 9367: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9368: | return $instance->shouldFakeJob($job); |
| 9369: | } |
| 9370: | /** |
| 9371: | * Push a raw payload onto the queue. |
| 9372: | * |
| 9373: | * @param string $payload |
| 9374: | * @param string|null $queue |
| 9375: | * @param array $options |
| 9376: | * @return mixed |
| 9377: | * @static |
| 9378: | */ |
| 9379: | public static function pushRaw($payload, $queue = null, $options = []) |
| 9380: | { |
| 9381: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9382: | return $instance->pushRaw($payload, $queue, $options); |
| 9383: | } |
| 9384: | /** |
| 9385: | * Push a new job onto the queue after (n) seconds. |
| 9386: | * |
| 9387: | * @param \DateTimeInterface|\DateInterval|int $delay |
| 9388: | * @param string|object $job |
| 9389: | * @param mixed $data |
| 9390: | * @param string|null $queue |
| 9391: | * @return mixed |
| 9392: | * @static |
| 9393: | */ |
| 9394: | public static function later($delay, $job, $data = '', $queue = null) |
| 9395: | { |
| 9396: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9397: | return $instance->later($delay, $job, $data, $queue); |
| 9398: | } |
| 9399: | /** |
| 9400: | * Push a new job onto the queue. |
| 9401: | * |
| 9402: | * @param string $queue |
| 9403: | * @param string|object $job |
| 9404: | * @param mixed $data |
| 9405: | * @return mixed |
| 9406: | * @static |
| 9407: | */ |
| 9408: | public static function pushOn($queue, $job, $data = '') |
| 9409: | { |
| 9410: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9411: | return $instance->pushOn($queue, $job, $data); |
| 9412: | } |
| 9413: | /** |
| 9414: | * Push a new job onto a specific queue after (n) seconds. |
| 9415: | * |
| 9416: | * @param string $queue |
| 9417: | * @param \DateTimeInterface|\DateInterval|int $delay |
| 9418: | * @param string|object $job |
| 9419: | * @param mixed $data |
| 9420: | * @return mixed |
| 9421: | * @static |
| 9422: | */ |
| 9423: | public static function laterOn($queue, $delay, $job, $data = '') |
| 9424: | { |
| 9425: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9426: | return $instance->laterOn($queue, $delay, $job, $data); |
| 9427: | } |
| 9428: | /** |
| 9429: | * Pop the next job off of the queue. |
| 9430: | * |
| 9431: | * @param string|null $queue |
| 9432: | * @return \Illuminate\Contracts\Queue\Job|null |
| 9433: | * @static |
| 9434: | */ |
| 9435: | public static function pop($queue = null) |
| 9436: | { |
| 9437: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9438: | return $instance->pop($queue); |
| 9439: | } |
| 9440: | /** |
| 9441: | * Push an array of jobs onto the queue. |
| 9442: | * |
| 9443: | * @param array $jobs |
| 9444: | * @param mixed $data |
| 9445: | * @param string|null $queue |
| 9446: | * @return mixed |
| 9447: | * @static |
| 9448: | */ |
| 9449: | public static function bulk($jobs, $data = '', $queue = null) |
| 9450: | { |
| 9451: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9452: | return $instance->bulk($jobs, $data, $queue); |
| 9453: | } |
| 9454: | /** |
| 9455: | * Get the jobs that have been pushed. |
| 9456: | * |
| 9457: | * @return array |
| 9458: | * @static |
| 9459: | */ |
| 9460: | public static function pushedJobs() |
| 9461: | { |
| 9462: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9463: | return $instance->pushedJobs(); |
| 9464: | } |
| 9465: | /** |
| 9466: | * Get the connection name for the queue. |
| 9467: | * |
| 9468: | * @return string |
| 9469: | * @static |
| 9470: | */ |
| 9471: | public static function getConnectionName() |
| 9472: | { |
| 9473: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9474: | return $instance->getConnectionName(); |
| 9475: | } |
| 9476: | /** |
| 9477: | * Set the connection name for the queue. |
| 9478: | * |
| 9479: | * @param string $name |
| 9480: | * @return \Illuminate\Support\Testing\Fakes\QueueFake |
| 9481: | * @static |
| 9482: | */ |
| 9483: | public static function setConnectionName($name) |
| 9484: | { |
| 9485: | /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */ |
| 9486: | return $instance->setConnectionName($name); |
| 9487: | } |
| 9488: | /** |
| 9489: | * Release a reserved job back onto the queue after (n) seconds. |
| 9490: | * |
| 9491: | * @param string $queue |
| 9492: | * @param \Illuminate\Queue\Jobs\DatabaseJobRecord $job |
| 9493: | * @param int $delay |
| 9494: | * @return mixed |
| 9495: | * @static |
| 9496: | */ |
| 9497: | public static function release($queue, $job, $delay) |
| 9498: | { |
| 9499: | /** @var \Illuminate\Queue\DatabaseQueue $instance */ |
| 9500: | return $instance->release($queue, $job, $delay); |
| 9501: | } |
| 9502: | /** |
| 9503: | * Delete a reserved job from the queue. |
| 9504: | * |
| 9505: | * @param string $queue |
| 9506: | * @param string $id |
| 9507: | * @return void |
| 9508: | * @throws \Throwable |
| 9509: | * @static |
| 9510: | */ |
| 9511: | public static function deleteReserved($queue, $id) |
| 9512: | { |
| 9513: | /** @var \Illuminate\Queue\DatabaseQueue $instance */ |
| 9514: | $instance->deleteReserved($queue, $id); |
| 9515: | } |
| 9516: | /** |
| 9517: | * Delete a reserved job from the reserved queue and release it. |
| 9518: | * |
| 9519: | * @param string $queue |
| 9520: | * @param \Illuminate\Queue\Jobs\DatabaseJob $job |
| 9521: | * @param int $delay |
| 9522: | * @return void |
| 9523: | * @static |
| 9524: | */ |
| 9525: | public static function deleteAndRelease($queue, $job, $delay) |
| 9526: | { |
| 9527: | /** @var \Illuminate\Queue\DatabaseQueue $instance */ |
| 9528: | $instance->deleteAndRelease($queue, $job, $delay); |
| 9529: | } |
| 9530: | /** |
| 9531: | * Delete all of the jobs from the queue. |
| 9532: | * |
| 9533: | * @param string $queue |
| 9534: | * @return int |
| 9535: | * @static |
| 9536: | */ |
| 9537: | public static function clear($queue) |
| 9538: | { |
| 9539: | /** @var \Illuminate\Queue\DatabaseQueue $instance */ |
| 9540: | return $instance->clear($queue); |
| 9541: | } |
| 9542: | /** |
| 9543: | * Get the queue or return the default. |
| 9544: | * |
| 9545: | * @param string|null $queue |
| 9546: | * @return string |
| 9547: | * @static |
| 9548: | */ |
| 9549: | public static function getQueue($queue) |
| 9550: | { |
| 9551: | /** @var \Illuminate\Queue\DatabaseQueue $instance */ |
| 9552: | return $instance->getQueue($queue); |
| 9553: | } |
| 9554: | /** |
| 9555: | * Get the underlying database instance. |
| 9556: | * |
| 9557: | * @return \Illuminate\Database\Connection |
| 9558: | * @static |
| 9559: | */ |
| 9560: | public static function getDatabase() |
| 9561: | { |
| 9562: | /** @var \Illuminate\Queue\DatabaseQueue $instance */ |
| 9563: | return $instance->getDatabase(); |
| 9564: | } |
| 9565: | /** |
| 9566: | * Get the backoff for an object-based queue handler. |
| 9567: | * |
| 9568: | * @param mixed $job |
| 9569: | * @return mixed |
| 9570: | * @static |
| 9571: | */ |
| 9572: | public static function getJobBackoff($job) |
| 9573: | { //Method inherited from \Illuminate\Queue\Queue |
| 9574: | /** @var \Illuminate\Queue\DatabaseQueue $instance */ |
| 9575: | return $instance->getJobBackoff($job); |
| 9576: | } |
| 9577: | /** |
| 9578: | * Get the expiration timestamp for an object-based queue handler. |
| 9579: | * |
| 9580: | * @param mixed $job |
| 9581: | * @return mixed |
| 9582: | * @static |
| 9583: | */ |
| 9584: | public static function getJobExpiration($job) |
| 9585: | { //Method inherited from \Illuminate\Queue\Queue |
| 9586: | /** @var \Illuminate\Queue\DatabaseQueue $instance */ |
| 9587: | return $instance->getJobExpiration($job); |
| 9588: | } |
| 9589: | /** |
| 9590: | * Register a callback to be executed when creating job payloads. |
| 9591: | * |
| 9592: | * @param callable|null $callback |
| 9593: | * @return void |
| 9594: | * @static |
| 9595: | */ |
| 9596: | public static function createPayloadUsing($callback) |
| 9597: | { //Method inherited from \Illuminate\Queue\Queue |
| 9598: | \Illuminate\Queue\DatabaseQueue::createPayloadUsing($callback); |
| 9599: | } |
| 9600: | /** |
| 9601: | * Get the container instance being used by the connection. |
| 9602: | * |
| 9603: | * @return \Illuminate\Container\Container |
| 9604: | * @static |
| 9605: | */ |
| 9606: | public static function getContainer() |
| 9607: | { //Method inherited from \Illuminate\Queue\Queue |
| 9608: | /** @var \Illuminate\Queue\DatabaseQueue $instance */ |
| 9609: | return $instance->getContainer(); |
| 9610: | } |
| 9611: | /** |
| 9612: | * Set the IoC container instance. |
| 9613: | * |
| 9614: | * @param \Illuminate\Container\Container $container |
| 9615: | * @return void |
| 9616: | * @static |
| 9617: | */ |
| 9618: | public static function setContainer($container) |
| 9619: | { //Method inherited from \Illuminate\Queue\Queue |
| 9620: | /** @var \Illuminate\Queue\DatabaseQueue $instance */ |
| 9621: | $instance->setContainer($container); |
| 9622: | } |
| 9623: | |
| 9624: | } |
| 9625: | /** |
| 9626: | * |
| 9627: | * |
| 9628: | * @see \Illuminate\Cache\RateLimiter |
| 9629: | */ |
| 9630: | class RateLimiter { |
| 9631: | /** |
| 9632: | * Register a named limiter configuration. |
| 9633: | * |
| 9634: | * @param string $name |
| 9635: | * @param \Closure $callback |
| 9636: | * @return \Illuminate\Cache\RateLimiter |
| 9637: | * @static |
| 9638: | */ |
| 9639: | public static function for($name, $callback) |
| 9640: | { |
| 9641: | /** @var \Illuminate\Cache\RateLimiter $instance */ |
| 9642: | return $instance->for($name, $callback); |
| 9643: | } |
| 9644: | /** |
| 9645: | * Get the given named rate limiter. |
| 9646: | * |
| 9647: | * @param string $name |
| 9648: | * @return \Closure |
| 9649: | * @static |
| 9650: | */ |
| 9651: | public static function limiter($name) |
| 9652: | { |
| 9653: | /** @var \Illuminate\Cache\RateLimiter $instance */ |
| 9654: | return $instance->limiter($name); |
| 9655: | } |
| 9656: | /** |
| 9657: | * Attempts to execute a callback if it's not limited. |
| 9658: | * |
| 9659: | * @param string $key |
| 9660: | * @param int $maxAttempts |
| 9661: | * @param \Closure $callback |
| 9662: | * @param int $decaySeconds |
| 9663: | * @return mixed |
| 9664: | * @static |
| 9665: | */ |
| 9666: | public static function attempt($key, $maxAttempts, $callback, $decaySeconds = 60) |
| 9667: | { |
| 9668: | /** @var \Illuminate\Cache\RateLimiter $instance */ |
| 9669: | return $instance->attempt($key, $maxAttempts, $callback, $decaySeconds); |
| 9670: | } |
| 9671: | /** |
| 9672: | * Determine if the given key has been "accessed" too many times. |
| 9673: | * |
| 9674: | * @param string $key |
| 9675: | * @param int $maxAttempts |
| 9676: | * @return bool |
| 9677: | * @static |
| 9678: | */ |
| 9679: | public static function tooManyAttempts($key, $maxAttempts) |
| 9680: | { |
| 9681: | /** @var \Illuminate\Cache\RateLimiter $instance */ |
| 9682: | return $instance->tooManyAttempts($key, $maxAttempts); |
| 9683: | } |
| 9684: | /** |
| 9685: | * Increment the counter for a given key for a given decay time. |
| 9686: | * |
| 9687: | * @param string $key |
| 9688: | * @param int $decaySeconds |
| 9689: | * @return int |
| 9690: | * @static |
| 9691: | */ |
| 9692: | public static function hit($key, $decaySeconds = 60) |
| 9693: | { |
| 9694: | /** @var \Illuminate\Cache\RateLimiter $instance */ |
| 9695: | return $instance->hit($key, $decaySeconds); |
| 9696: | } |
| 9697: | /** |
| 9698: | * Get the number of attempts for the given key. |
| 9699: | * |
| 9700: | * @param string $key |
| 9701: | * @return mixed |
| 9702: | * @static |
| 9703: | */ |
| 9704: | public static function attempts($key) |
| 9705: | { |
| 9706: | /** @var \Illuminate\Cache\RateLimiter $instance */ |
| 9707: | return $instance->attempts($key); |
| 9708: | } |
| 9709: | /** |
| 9710: | * Reset the number of attempts for the given key. |
| 9711: | * |
| 9712: | * @param string $key |
| 9713: | * @return mixed |
| 9714: | * @static |
| 9715: | */ |
| 9716: | public static function resetAttempts($key) |
| 9717: | { |
| 9718: | /** @var \Illuminate\Cache\RateLimiter $instance */ |
| 9719: | return $instance->resetAttempts($key); |
| 9720: | } |
| 9721: | /** |
| 9722: | * Get the number of retries left for the given key. |
| 9723: | * |
| 9724: | * @param string $key |
| 9725: | * @param int $maxAttempts |
| 9726: | * @return int |
| 9727: | * @static |
| 9728: | */ |
| 9729: | public static function remaining($key, $maxAttempts) |
| 9730: | { |
| 9731: | /** @var \Illuminate\Cache\RateLimiter $instance */ |
| 9732: | return $instance->remaining($key, $maxAttempts); |
| 9733: | } |
| 9734: | /** |
| 9735: | * Get the number of retries left for the given key. |
| 9736: | * |
| 9737: | * @param string $key |
| 9738: | * @param int $maxAttempts |
| 9739: | * @return int |
| 9740: | * @static |
| 9741: | */ |
| 9742: | public static function retriesLeft($key, $maxAttempts) |
| 9743: | { |
| 9744: | /** @var \Illuminate\Cache\RateLimiter $instance */ |
| 9745: | return $instance->retriesLeft($key, $maxAttempts); |
| 9746: | } |
| 9747: | /** |
| 9748: | * Clear the hits and lockout timer for the given key. |
| 9749: | * |
| 9750: | * @param string $key |
| 9751: | * @return void |
| 9752: | * @static |
| 9753: | */ |
| 9754: | public static function clear($key) |
| 9755: | { |
| 9756: | /** @var \Illuminate\Cache\RateLimiter $instance */ |
| 9757: | $instance->clear($key); |
| 9758: | } |
| 9759: | /** |
| 9760: | * Get the number of seconds until the "key" is accessible again. |
| 9761: | * |
| 9762: | * @param string $key |
| 9763: | * @return int |
| 9764: | * @static |
| 9765: | */ |
| 9766: | public static function availableIn($key) |
| 9767: | { |
| 9768: | /** @var \Illuminate\Cache\RateLimiter $instance */ |
| 9769: | return $instance->availableIn($key); |
| 9770: | } |
| 9771: | /** |
| 9772: | * Clean the rate limiter key from unicode characters. |
| 9773: | * |
| 9774: | * @param string $key |
| 9775: | * @return string |
| 9776: | * @static |
| 9777: | */ |
| 9778: | public static function cleanRateLimiterKey($key) |
| 9779: | { |
| 9780: | /** @var \Illuminate\Cache\RateLimiter $instance */ |
| 9781: | return $instance->cleanRateLimiterKey($key); |
| 9782: | } |
| 9783: | |
| 9784: | } |
| 9785: | /** |
| 9786: | * |
| 9787: | * |
| 9788: | * @see \Illuminate\Routing\Redirector |
| 9789: | */ |
| 9790: | class Redirect { |
| 9791: | /** |
| 9792: | * Create a new redirect response to the "home" route. |
| 9793: | * |
| 9794: | * @param int $status |
| 9795: | * @return \Illuminate\Http\RedirectResponse |
| 9796: | * @deprecated Will be removed in a future Laravel version. |
| 9797: | * @static |
| 9798: | */ |
| 9799: | public static function home($status = 302) |
| 9800: | { |
| 9801: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9802: | return $instance->home($status); |
| 9803: | } |
| 9804: | /** |
| 9805: | * Create a new redirect response to the previous location. |
| 9806: | * |
| 9807: | * @param int $status |
| 9808: | * @param array $headers |
| 9809: | * @param mixed $fallback |
| 9810: | * @return \Illuminate\Http\RedirectResponse |
| 9811: | * @static |
| 9812: | */ |
| 9813: | public static function back($status = 302, $headers = [], $fallback = false) |
| 9814: | { |
| 9815: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9816: | return $instance->back($status, $headers, $fallback); |
| 9817: | } |
| 9818: | /** |
| 9819: | * Create a new redirect response to the current URI. |
| 9820: | * |
| 9821: | * @param int $status |
| 9822: | * @param array $headers |
| 9823: | * @return \Illuminate\Http\RedirectResponse |
| 9824: | * @static |
| 9825: | */ |
| 9826: | public static function refresh($status = 302, $headers = []) |
| 9827: | { |
| 9828: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9829: | return $instance->refresh($status, $headers); |
| 9830: | } |
| 9831: | /** |
| 9832: | * Create a new redirect response, while putting the current URL in the session. |
| 9833: | * |
| 9834: | * @param string $path |
| 9835: | * @param int $status |
| 9836: | * @param array $headers |
| 9837: | * @param bool|null $secure |
| 9838: | * @return \Illuminate\Http\RedirectResponse |
| 9839: | * @static |
| 9840: | */ |
| 9841: | public static function guest($path, $status = 302, $headers = [], $secure = null) |
| 9842: | { |
| 9843: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9844: | return $instance->guest($path, $status, $headers, $secure); |
| 9845: | } |
| 9846: | /** |
| 9847: | * Create a new redirect response to the previously intended location. |
| 9848: | * |
| 9849: | * @param mixed $default |
| 9850: | * @param int $status |
| 9851: | * @param array $headers |
| 9852: | * @param bool|null $secure |
| 9853: | * @return \Illuminate\Http\RedirectResponse |
| 9854: | * @static |
| 9855: | */ |
| 9856: | public static function intended($default = '/', $status = 302, $headers = [], $secure = null) |
| 9857: | { |
| 9858: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9859: | return $instance->intended($default, $status, $headers, $secure); |
| 9860: | } |
| 9861: | /** |
| 9862: | * Set the intended url. |
| 9863: | * |
| 9864: | * @param string $url |
| 9865: | * @return \Illuminate\Routing\Redirector |
| 9866: | * @static |
| 9867: | */ |
| 9868: | public static function setIntendedUrl($url) |
| 9869: | { |
| 9870: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9871: | return $instance->setIntendedUrl($url); |
| 9872: | } |
| 9873: | /** |
| 9874: | * Create a new redirect response to the given path. |
| 9875: | * |
| 9876: | * @param string $path |
| 9877: | * @param int $status |
| 9878: | * @param array $headers |
| 9879: | * @param bool|null $secure |
| 9880: | * @return \Illuminate\Http\RedirectResponse |
| 9881: | * @static |
| 9882: | */ |
| 9883: | public static function to($path, $status = 302, $headers = [], $secure = null) |
| 9884: | { |
| 9885: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9886: | return $instance->to($path, $status, $headers, $secure); |
| 9887: | } |
| 9888: | /** |
| 9889: | * Create a new redirect response to an external URL (no validation). |
| 9890: | * |
| 9891: | * @param string $path |
| 9892: | * @param int $status |
| 9893: | * @param array $headers |
| 9894: | * @return \Illuminate\Http\RedirectResponse |
| 9895: | * @static |
| 9896: | */ |
| 9897: | public static function away($path, $status = 302, $headers = []) |
| 9898: | { |
| 9899: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9900: | return $instance->away($path, $status, $headers); |
| 9901: | } |
| 9902: | /** |
| 9903: | * Create a new redirect response to the given HTTPS path. |
| 9904: | * |
| 9905: | * @param string $path |
| 9906: | * @param int $status |
| 9907: | * @param array $headers |
| 9908: | * @return \Illuminate\Http\RedirectResponse |
| 9909: | * @static |
| 9910: | */ |
| 9911: | public static function secure($path, $status = 302, $headers = []) |
| 9912: | { |
| 9913: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9914: | return $instance->secure($path, $status, $headers); |
| 9915: | } |
| 9916: | /** |
| 9917: | * Create a new redirect response to a named route. |
| 9918: | * |
| 9919: | * @param string $route |
| 9920: | * @param mixed $parameters |
| 9921: | * @param int $status |
| 9922: | * @param array $headers |
| 9923: | * @return \Illuminate\Http\RedirectResponse |
| 9924: | * @static |
| 9925: | */ |
| 9926: | public static function route($route, $parameters = [], $status = 302, $headers = []) |
| 9927: | { |
| 9928: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9929: | return $instance->route($route, $parameters, $status, $headers); |
| 9930: | } |
| 9931: | /** |
| 9932: | * Create a new redirect response to a signed named route. |
| 9933: | * |
| 9934: | * @param string $route |
| 9935: | * @param mixed $parameters |
| 9936: | * @param \DateTimeInterface|\DateInterval|int|null $expiration |
| 9937: | * @param int $status |
| 9938: | * @param array $headers |
| 9939: | * @return \Illuminate\Http\RedirectResponse |
| 9940: | * @static |
| 9941: | */ |
| 9942: | public static function signedRoute($route, $parameters = [], $expiration = null, $status = 302, $headers = []) |
| 9943: | { |
| 9944: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9945: | return $instance->signedRoute($route, $parameters, $expiration, $status, $headers); |
| 9946: | } |
| 9947: | /** |
| 9948: | * Create a new redirect response to a signed named route. |
| 9949: | * |
| 9950: | * @param string $route |
| 9951: | * @param \DateTimeInterface|\DateInterval|int|null $expiration |
| 9952: | * @param mixed $parameters |
| 9953: | * @param int $status |
| 9954: | * @param array $headers |
| 9955: | * @return \Illuminate\Http\RedirectResponse |
| 9956: | * @static |
| 9957: | */ |
| 9958: | public static function temporarySignedRoute($route, $expiration, $parameters = [], $status = 302, $headers = []) |
| 9959: | { |
| 9960: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9961: | return $instance->temporarySignedRoute($route, $expiration, $parameters, $status, $headers); |
| 9962: | } |
| 9963: | /** |
| 9964: | * Create a new redirect response to a controller action. |
| 9965: | * |
| 9966: | * @param string|array $action |
| 9967: | * @param mixed $parameters |
| 9968: | * @param int $status |
| 9969: | * @param array $headers |
| 9970: | * @return \Illuminate\Http\RedirectResponse |
| 9971: | * @static |
| 9972: | */ |
| 9973: | public static function action($action, $parameters = [], $status = 302, $headers = []) |
| 9974: | { |
| 9975: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9976: | return $instance->action($action, $parameters, $status, $headers); |
| 9977: | } |
| 9978: | /** |
| 9979: | * Get the URL generator instance. |
| 9980: | * |
| 9981: | * @return \Illuminate\Routing\UrlGenerator |
| 9982: | * @static |
| 9983: | */ |
| 9984: | public static function getUrlGenerator() |
| 9985: | { |
| 9986: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9987: | return $instance->getUrlGenerator(); |
| 9988: | } |
| 9989: | /** |
| 9990: | * Set the active session store. |
| 9991: | * |
| 9992: | * @param \Illuminate\Session\Store $session |
| 9993: | * @return void |
| 9994: | * @static |
| 9995: | */ |
| 9996: | public static function setSession($session) |
| 9997: | { |
| 9998: | /** @var \Illuminate\Routing\Redirector $instance */ |
| 9999: | $instance->setSession($session); |
| 10000: | } |
| 10001: | /** |
| 10002: | * Register a custom macro. |
| 10003: | * |
| 10004: | * @param string $name |
| 10005: | * @param object|callable $macro |
| 10006: | * @return void |
| 10007: | * @static |
| 10008: | */ |
| 10009: | public static function macro($name, $macro) |
| 10010: | { |
| 10011: | \Illuminate\Routing\Redirector::macro($name, $macro); |
| 10012: | } |
| 10013: | /** |
| 10014: | * Mix another object into the class. |
| 10015: | * |
| 10016: | * @param object $mixin |
| 10017: | * @param bool $replace |
| 10018: | * @return void |
| 10019: | * @throws \ReflectionException |
| 10020: | * @static |
| 10021: | */ |
| 10022: | public static function mixin($mixin, $replace = true) |
| 10023: | { |
| 10024: | \Illuminate\Routing\Redirector::mixin($mixin, $replace); |
| 10025: | } |
| 10026: | /** |
| 10027: | * Checks if macro is registered. |
| 10028: | * |
| 10029: | * @param string $name |
| 10030: | * @return bool |
| 10031: | * @static |
| 10032: | */ |
| 10033: | public static function hasMacro($name) |
| 10034: | { |
| 10035: | return \Illuminate\Routing\Redirector::hasMacro($name); |
| 10036: | } |
| 10037: | /** |
| 10038: | * Flush the existing macros. |
| 10039: | * |
| 10040: | * @return void |
| 10041: | * @static |
| 10042: | */ |
| 10043: | public static function flushMacros() |
| 10044: | { |
| 10045: | \Illuminate\Routing\Redirector::flushMacros(); |
| 10046: | } |
| 10047: | |
| 10048: | } |
| 10049: | /** |
| 10050: | * |
| 10051: | * |
| 10052: | * @method static mixed filterFiles(mixed $files) |
| 10053: | * @see \Illuminate\Http\Request |
| 10054: | */ |
| 10055: | class Request { |
| 10056: | /** |
| 10057: | * Create a new Illuminate HTTP request from server variables. |
| 10058: | * |
| 10059: | * @return static |
| 10060: | * @static |
| 10061: | */ |
| 10062: | public static function capture() |
| 10063: | { |
| 10064: | return \Illuminate\Http\Request::capture(); |
| 10065: | } |
| 10066: | /** |
| 10067: | * Return the Request instance. |
| 10068: | * |
| 10069: | * @return \Illuminate\Http\Request |
| 10070: | * @static |
| 10071: | */ |
| 10072: | public static function instance() |
| 10073: | { |
| 10074: | /** @var \Illuminate\Http\Request $instance */ |
| 10075: | return $instance->instance(); |
| 10076: | } |
| 10077: | /** |
| 10078: | * Get the request method. |
| 10079: | * |
| 10080: | * @return string |
| 10081: | * @static |
| 10082: | */ |
| 10083: | public static function method() |
| 10084: | { |
| 10085: | /** @var \Illuminate\Http\Request $instance */ |
| 10086: | return $instance->method(); |
| 10087: | } |
| 10088: | /** |
| 10089: | * Get the root URL for the application. |
| 10090: | * |
| 10091: | * @return string |
| 10092: | * @static |
| 10093: | */ |
| 10094: | public static function root() |
| 10095: | { |
| 10096: | /** @var \Illuminate\Http\Request $instance */ |
| 10097: | return $instance->root(); |
| 10098: | } |
| 10099: | /** |
| 10100: | * Get the URL (no query string) for the request. |
| 10101: | * |
| 10102: | * @return string |
| 10103: | * @static |
| 10104: | */ |
| 10105: | public static function url() |
| 10106: | { |
| 10107: | /** @var \Illuminate\Http\Request $instance */ |
| 10108: | return $instance->url(); |
| 10109: | } |
| 10110: | /** |
| 10111: | * Get the full URL for the request. |
| 10112: | * |
| 10113: | * @return string |
| 10114: | * @static |
| 10115: | */ |
| 10116: | public static function fullUrl() |
| 10117: | { |
| 10118: | /** @var \Illuminate\Http\Request $instance */ |
| 10119: | return $instance->fullUrl(); |
| 10120: | } |
| 10121: | /** |
| 10122: | * Get the full URL for the request with the added query string parameters. |
| 10123: | * |
| 10124: | * @param array $query |
| 10125: | * @return string |
| 10126: | * @static |
| 10127: | */ |
| 10128: | public static function fullUrlWithQuery($query) |
| 10129: | { |
| 10130: | /** @var \Illuminate\Http\Request $instance */ |
| 10131: | return $instance->fullUrlWithQuery($query); |
| 10132: | } |
| 10133: | /** |
| 10134: | * Get the full URL for the request without the given query string parameters. |
| 10135: | * |
| 10136: | * @param array|string $keys |
| 10137: | * @return string |
| 10138: | * @static |
| 10139: | */ |
| 10140: | public static function fullUrlWithoutQuery($keys) |
| 10141: | { |
| 10142: | /** @var \Illuminate\Http\Request $instance */ |
| 10143: | return $instance->fullUrlWithoutQuery($keys); |
| 10144: | } |
| 10145: | /** |
| 10146: | * Get the current path info for the request. |
| 10147: | * |
| 10148: | * @return string |
| 10149: | * @static |
| 10150: | */ |
| 10151: | public static function path() |
| 10152: | { |
| 10153: | /** @var \Illuminate\Http\Request $instance */ |
| 10154: | return $instance->path(); |
| 10155: | } |
| 10156: | /** |
| 10157: | * Get the current decoded path info for the request. |
| 10158: | * |
| 10159: | * @return string |
| 10160: | * @static |
| 10161: | */ |
| 10162: | public static function decodedPath() |
| 10163: | { |
| 10164: | /** @var \Illuminate\Http\Request $instance */ |
| 10165: | return $instance->decodedPath(); |
| 10166: | } |
| 10167: | /** |
| 10168: | * Get a segment from the URI (1 based index). |
| 10169: | * |
| 10170: | * @param int $index |
| 10171: | * @param string|null $default |
| 10172: | * @return string|null |
| 10173: | * @static |
| 10174: | */ |
| 10175: | public static function segment($index, $default = null) |
| 10176: | { |
| 10177: | /** @var \Illuminate\Http\Request $instance */ |
| 10178: | return $instance->segment($index, $default); |
| 10179: | } |
| 10180: | /** |
| 10181: | * Get all of the segments for the request path. |
| 10182: | * |
| 10183: | * @return array |
| 10184: | * @static |
| 10185: | */ |
| 10186: | public static function segments() |
| 10187: | { |
| 10188: | /** @var \Illuminate\Http\Request $instance */ |
| 10189: | return $instance->segments(); |
| 10190: | } |
| 10191: | /** |
| 10192: | * Determine if the current request URI matches a pattern. |
| 10193: | * |
| 10194: | * @param mixed $patterns |
| 10195: | * @return bool |
| 10196: | * @static |
| 10197: | */ |
| 10198: | public static function is(...$patterns) |
| 10199: | { |
| 10200: | /** @var \Illuminate\Http\Request $instance */ |
| 10201: | return $instance->is(...$patterns); |
| 10202: | } |
| 10203: | /** |
| 10204: | * Determine if the route name matches a given pattern. |
| 10205: | * |
| 10206: | * @param mixed $patterns |
| 10207: | * @return bool |
| 10208: | * @static |
| 10209: | */ |
| 10210: | public static function routeIs(...$patterns) |
| 10211: | { |
| 10212: | /** @var \Illuminate\Http\Request $instance */ |
| 10213: | return $instance->routeIs(...$patterns); |
| 10214: | } |
| 10215: | /** |
| 10216: | * Determine if the current request URL and query string match a pattern. |
| 10217: | * |
| 10218: | * @param mixed $patterns |
| 10219: | * @return bool |
| 10220: | * @static |
| 10221: | */ |
| 10222: | public static function fullUrlIs(...$patterns) |
| 10223: | { |
| 10224: | /** @var \Illuminate\Http\Request $instance */ |
| 10225: | return $instance->fullUrlIs(...$patterns); |
| 10226: | } |
| 10227: | /** |
| 10228: | * Get the host name. |
| 10229: | * |
| 10230: | * @return string |
| 10231: | * @static |
| 10232: | */ |
| 10233: | public static function host() |
| 10234: | { |
| 10235: | /** @var \Illuminate\Http\Request $instance */ |
| 10236: | return $instance->host(); |
| 10237: | } |
| 10238: | /** |
| 10239: | * Get the HTTP host being requested. |
| 10240: | * |
| 10241: | * @return string |
| 10242: | * @static |
| 10243: | */ |
| 10244: | public static function httpHost() |
| 10245: | { |
| 10246: | /** @var \Illuminate\Http\Request $instance */ |
| 10247: | return $instance->httpHost(); |
| 10248: | } |
| 10249: | /** |
| 10250: | * Get the scheme and HTTP host. |
| 10251: | * |
| 10252: | * @return string |
| 10253: | * @static |
| 10254: | */ |
| 10255: | public static function schemeAndHttpHost() |
| 10256: | { |
| 10257: | /** @var \Illuminate\Http\Request $instance */ |
| 10258: | return $instance->schemeAndHttpHost(); |
| 10259: | } |
| 10260: | /** |
| 10261: | * Determine if the request is the result of an AJAX call. |
| 10262: | * |
| 10263: | * @return bool |
| 10264: | * @static |
| 10265: | */ |
| 10266: | public static function ajax() |
| 10267: | { |
| 10268: | /** @var \Illuminate\Http\Request $instance */ |
| 10269: | return $instance->ajax(); |
| 10270: | } |
| 10271: | /** |
| 10272: | * Determine if the request is the result of a PJAX call. |
| 10273: | * |
| 10274: | * @return bool |
| 10275: | * @static |
| 10276: | */ |
| 10277: | public static function pjax() |
| 10278: | { |
| 10279: | /** @var \Illuminate\Http\Request $instance */ |
| 10280: | return $instance->pjax(); |
| 10281: | } |
| 10282: | /** |
| 10283: | * Determine if the request is the result of a prefetch call. |
| 10284: | * |
| 10285: | * @return bool |
| 10286: | * @static |
| 10287: | */ |
| 10288: | public static function prefetch() |
| 10289: | { |
| 10290: | /** @var \Illuminate\Http\Request $instance */ |
| 10291: | return $instance->prefetch(); |
| 10292: | } |
| 10293: | /** |
| 10294: | * Determine if the request is over HTTPS. |
| 10295: | * |
| 10296: | * @return bool |
| 10297: | * @static |
| 10298: | */ |
| 10299: | public static function secure() |
| 10300: | { |
| 10301: | /** @var \Illuminate\Http\Request $instance */ |
| 10302: | return $instance->secure(); |
| 10303: | } |
| 10304: | /** |
| 10305: | * Get the client IP address. |
| 10306: | * |
| 10307: | * @return string|null |
| 10308: | * @static |
| 10309: | */ |
| 10310: | public static function ip() |
| 10311: | { |
| 10312: | /** @var \Illuminate\Http\Request $instance */ |
| 10313: | return $instance->ip(); |
| 10314: | } |
| 10315: | /** |
| 10316: | * Get the client IP addresses. |
| 10317: | * |
| 10318: | * @return array |
| 10319: | * @static |
| 10320: | */ |
| 10321: | public static function ips() |
| 10322: | { |
| 10323: | /** @var \Illuminate\Http\Request $instance */ |
| 10324: | return $instance->ips(); |
| 10325: | } |
| 10326: | /** |
| 10327: | * Get the client user agent. |
| 10328: | * |
| 10329: | * @return string|null |
| 10330: | * @static |
| 10331: | */ |
| 10332: | public static function userAgent() |
| 10333: | { |
| 10334: | /** @var \Illuminate\Http\Request $instance */ |
| 10335: | return $instance->userAgent(); |
| 10336: | } |
| 10337: | /** |
| 10338: | * Merge new input into the current request's input array. |
| 10339: | * |
| 10340: | * @param array $input |
| 10341: | * @return \Illuminate\Http\Request |
| 10342: | * @static |
| 10343: | */ |
| 10344: | public static function merge($input) |
| 10345: | { |
| 10346: | /** @var \Illuminate\Http\Request $instance */ |
| 10347: | return $instance->merge($input); |
| 10348: | } |
| 10349: | /** |
| 10350: | * Merge new input into the request's input, but only when that key is missing from the request. |
| 10351: | * |
| 10352: | * @param array $input |
| 10353: | * @return \Illuminate\Http\Request |
| 10354: | * @static |
| 10355: | */ |
| 10356: | public static function mergeIfMissing($input) |
| 10357: | { |
| 10358: | /** @var \Illuminate\Http\Request $instance */ |
| 10359: | return $instance->mergeIfMissing($input); |
| 10360: | } |
| 10361: | /** |
| 10362: | * Replace the input for the current request. |
| 10363: | * |
| 10364: | * @param array $input |
| 10365: | * @return \Illuminate\Http\Request |
| 10366: | * @static |
| 10367: | */ |
| 10368: | public static function replace($input) |
| 10369: | { |
| 10370: | /** @var \Illuminate\Http\Request $instance */ |
| 10371: | return $instance->replace($input); |
| 10372: | } |
| 10373: | /** |
| 10374: | * This method belongs to Symfony HttpFoundation and is not usually needed when using Laravel. |
| 10375: | * |
| 10376: | * Instead, you may use the "input" method. |
| 10377: | * |
| 10378: | * @param string $key |
| 10379: | * @param mixed $default |
| 10380: | * @return mixed |
| 10381: | * @static |
| 10382: | */ |
| 10383: | public static function get($key, $default = null) |
| 10384: | { |
| 10385: | /** @var \Illuminate\Http\Request $instance */ |
| 10386: | return $instance->get($key, $default); |
| 10387: | } |
| 10388: | /** |
| 10389: | * Get the JSON payload for the request. |
| 10390: | * |
| 10391: | * @param string|null $key |
| 10392: | * @param mixed $default |
| 10393: | * @return \Symfony\Component\HttpFoundation\ParameterBag|mixed |
| 10394: | * @static |
| 10395: | */ |
| 10396: | public static function json($key = null, $default = null) |
| 10397: | { |
| 10398: | /** @var \Illuminate\Http\Request $instance */ |
| 10399: | return $instance->json($key, $default); |
| 10400: | } |
| 10401: | /** |
| 10402: | * Create a new request instance from the given Laravel request. |
| 10403: | * |
| 10404: | * @param \Illuminate\Http\Request $from |
| 10405: | * @param \Illuminate\Http\Request|null $to |
| 10406: | * @return static |
| 10407: | * @static |
| 10408: | */ |
| 10409: | public static function createFrom($from, $to = null) |
| 10410: | { |
| 10411: | return \Illuminate\Http\Request::createFrom($from, $to); |
| 10412: | } |
| 10413: | /** |
| 10414: | * Create an Illuminate request from a Symfony instance. |
| 10415: | * |
| 10416: | * @param \Symfony\Component\HttpFoundation\Request $request |
| 10417: | * @return static |
| 10418: | * @static |
| 10419: | */ |
| 10420: | public static function createFromBase($request) |
| 10421: | { |
| 10422: | return \Illuminate\Http\Request::createFromBase($request); |
| 10423: | } |
| 10424: | /** |
| 10425: | * Clones a request and overrides some of its parameters. |
| 10426: | * |
| 10427: | * @return static |
| 10428: | * @param array $query The GET parameters |
| 10429: | * @param array $request The POST parameters |
| 10430: | * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...) |
| 10431: | * @param array $cookies The COOKIE parameters |
| 10432: | * @param array $files The FILES parameters |
| 10433: | * @param array $server The SERVER parameters |
| 10434: | * @static |
| 10435: | */ |
| 10436: | public static function duplicate($query = null, $request = null, $attributes = null, $cookies = null, $files = null, $server = null) |
| 10437: | { |
| 10438: | /** @var \Illuminate\Http\Request $instance */ |
| 10439: | return $instance->duplicate($query, $request, $attributes, $cookies, $files, $server); |
| 10440: | } |
| 10441: | /** |
| 10442: | * Whether the request contains a Session object. |
| 10443: | * |
| 10444: | * This method does not give any information about the state of the session object, |
| 10445: | * like whether the session is started or not. It is just a way to check if this Request |
| 10446: | * is associated with a Session instance. |
| 10447: | * |
| 10448: | * @param bool $skipIfUninitialized When true, ignores factories injected by `setSessionFactory` |
| 10449: | * @static |
| 10450: | */ |
| 10451: | public static function hasSession($skipIfUninitialized = false) |
| 10452: | { |
| 10453: | /** @var \Illuminate\Http\Request $instance */ |
| 10454: | return $instance->hasSession($skipIfUninitialized); |
| 10455: | } |
| 10456: | /** |
| 10457: | * Gets the Session. |
| 10458: | * |
| 10459: | * @throws SessionNotFoundException When session is not set properly |
| 10460: | * @static |
| 10461: | */ |
| 10462: | public static function getSession() |
| 10463: | { |
| 10464: | /** @var \Illuminate\Http\Request $instance */ |
| 10465: | return $instance->getSession(); |
| 10466: | } |
| 10467: | /** |
| 10468: | * Get the session associated with the request. |
| 10469: | * |
| 10470: | * @return \Illuminate\Contracts\Session\Session |
| 10471: | * @throws \RuntimeException |
| 10472: | * @static |
| 10473: | */ |
| 10474: | public static function session() |
| 10475: | { |
| 10476: | /** @var \Illuminate\Http\Request $instance */ |
| 10477: | return $instance->session(); |
| 10478: | } |
| 10479: | /** |
| 10480: | * Set the session instance on the request. |
| 10481: | * |
| 10482: | * @param \Illuminate\Contracts\Session\Session $session |
| 10483: | * @return void |
| 10484: | * @static |
| 10485: | */ |
| 10486: | public static function setLaravelSession($session) |
| 10487: | { |
| 10488: | /** @var \Illuminate\Http\Request $instance */ |
| 10489: | $instance->setLaravelSession($session); |
| 10490: | } |
| 10491: | /** |
| 10492: | * Get the user making the request. |
| 10493: | * |
| 10494: | * @param string|null $guard |
| 10495: | * @return mixed |
| 10496: | * @static |
| 10497: | */ |
| 10498: | public static function user($guard = null) |
| 10499: | { |
| 10500: | /** @var \Illuminate\Http\Request $instance */ |
| 10501: | return $instance->user($guard); |
| 10502: | } |
| 10503: | /** |
| 10504: | * Get the route handling the request. |
| 10505: | * |
| 10506: | * @param string|null $param |
| 10507: | * @param mixed $default |
| 10508: | * @return \Illuminate\Routing\Route|object|string|null |
| 10509: | * @static |
| 10510: | */ |
| 10511: | public static function route($param = null, $default = null) |
| 10512: | { |
| 10513: | /** @var \Illuminate\Http\Request $instance */ |
| 10514: | return $instance->route($param, $default); |
| 10515: | } |
| 10516: | /** |
| 10517: | * Get a unique fingerprint for the request / route / IP address. |
| 10518: | * |
| 10519: | * @return string |
| 10520: | * @throws \RuntimeException |
| 10521: | * @static |
| 10522: | */ |
| 10523: | public static function fingerprint() |
| 10524: | { |
| 10525: | /** @var \Illuminate\Http\Request $instance */ |
| 10526: | return $instance->fingerprint(); |
| 10527: | } |
| 10528: | /** |
| 10529: | * Set the JSON payload for the request. |
| 10530: | * |
| 10531: | * @param \Symfony\Component\HttpFoundation\ParameterBag $json |
| 10532: | * @return \Illuminate\Http\Request |
| 10533: | * @static |
| 10534: | */ |
| 10535: | public static function setJson($json) |
| 10536: | { |
| 10537: | /** @var \Illuminate\Http\Request $instance */ |
| 10538: | return $instance->setJson($json); |
| 10539: | } |
| 10540: | /** |
| 10541: | * Get the user resolver callback. |
| 10542: | * |
| 10543: | * @return \Closure |
| 10544: | * @static |
| 10545: | */ |
| 10546: | public static function getUserResolver() |
| 10547: | { |
| 10548: | /** @var \Illuminate\Http\Request $instance */ |
| 10549: | return $instance->getUserResolver(); |
| 10550: | } |
| 10551: | /** |
| 10552: | * Set the user resolver callback. |
| 10553: | * |
| 10554: | * @param \Closure $callback |
| 10555: | * @return \Illuminate\Http\Request |
| 10556: | * @static |
| 10557: | */ |
| 10558: | public static function setUserResolver($callback) |
| 10559: | { |
| 10560: | /** @var \Illuminate\Http\Request $instance */ |
| 10561: | return $instance->setUserResolver($callback); |
| 10562: | } |
| 10563: | /** |
| 10564: | * Get the route resolver callback. |
| 10565: | * |
| 10566: | * @return \Closure |
| 10567: | * @static |
| 10568: | */ |
| 10569: | public static function getRouteResolver() |
| 10570: | { |
| 10571: | /** @var \Illuminate\Http\Request $instance */ |
| 10572: | return $instance->getRouteResolver(); |
| 10573: | } |
| 10574: | /** |
| 10575: | * Set the route resolver callback. |
| 10576: | * |
| 10577: | * @param \Closure $callback |
| 10578: | * @return \Illuminate\Http\Request |
| 10579: | * @static |
| 10580: | */ |
| 10581: | public static function setRouteResolver($callback) |
| 10582: | { |
| 10583: | /** @var \Illuminate\Http\Request $instance */ |
| 10584: | return $instance->setRouteResolver($callback); |
| 10585: | } |
| 10586: | /** |
| 10587: | * Get all of the input and files for the request. |
| 10588: | * |
| 10589: | * @return array |
| 10590: | * @static |
| 10591: | */ |
| 10592: | public static function toArray() |
| 10593: | { |
| 10594: | /** @var \Illuminate\Http\Request $instance */ |
| 10595: | return $instance->toArray(); |
| 10596: | } |
| 10597: | /** |
| 10598: | * Determine if the given offset exists. |
| 10599: | * |
| 10600: | * @param string $offset |
| 10601: | * @return bool |
| 10602: | * @static |
| 10603: | */ |
| 10604: | public static function offsetExists($offset) |
| 10605: | { |
| 10606: | /** @var \Illuminate\Http\Request $instance */ |
| 10607: | return $instance->offsetExists($offset); |
| 10608: | } |
| 10609: | /** |
| 10610: | * Get the value at the given offset. |
| 10611: | * |
| 10612: | * @param string $offset |
| 10613: | * @return mixed |
| 10614: | * @static |
| 10615: | */ |
| 10616: | public static function offsetGet($offset) |
| 10617: | { |
| 10618: | /** @var \Illuminate\Http\Request $instance */ |
| 10619: | return $instance->offsetGet($offset); |
| 10620: | } |
| 10621: | /** |
| 10622: | * Set the value at the given offset. |
| 10623: | * |
| 10624: | * @param string $offset |
| 10625: | * @param mixed $value |
| 10626: | * @return void |
| 10627: | * @static |
| 10628: | */ |
| 10629: | public static function offsetSet($offset, $value) |
| 10630: | { |
| 10631: | /** @var \Illuminate\Http\Request $instance */ |
| 10632: | $instance->offsetSet($offset, $value); |
| 10633: | } |
| 10634: | /** |
| 10635: | * Remove the value at the given offset. |
| 10636: | * |
| 10637: | * @param string $offset |
| 10638: | * @return void |
| 10639: | * @static |
| 10640: | */ |
| 10641: | public static function offsetUnset($offset) |
| 10642: | { |
| 10643: | /** @var \Illuminate\Http\Request $instance */ |
| 10644: | $instance->offsetUnset($offset); |
| 10645: | } |
| 10646: | /** |
| 10647: | * Sets the parameters for this request. |
| 10648: | * |
| 10649: | * This method also re-initializes all properties. |
| 10650: | * |
| 10651: | * @param array $query The GET parameters |
| 10652: | * @param array $request The POST parameters |
| 10653: | * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...) |
| 10654: | * @param array $cookies The COOKIE parameters |
| 10655: | * @param array $files The FILES parameters |
| 10656: | * @param array $server The SERVER parameters |
| 10657: | * @param string|resource|null $content The raw body data |
| 10658: | * @static |
| 10659: | */ |
| 10660: | public static function initialize($query = [], $request = [], $attributes = [], $cookies = [], $files = [], $server = [], $content = null) |
| 10661: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10662: | /** @var \Illuminate\Http\Request $instance */ |
| 10663: | return $instance->initialize($query, $request, $attributes, $cookies, $files, $server, $content); |
| 10664: | } |
| 10665: | /** |
| 10666: | * Creates a new request with values from PHP's super globals. |
| 10667: | * |
| 10668: | * @static |
| 10669: | */ |
| 10670: | public static function createFromGlobals() |
| 10671: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10672: | return \Illuminate\Http\Request::createFromGlobals(); |
| 10673: | } |
| 10674: | /** |
| 10675: | * Creates a Request based on a given URI and configuration. |
| 10676: | * |
| 10677: | * The information contained in the URI always take precedence |
| 10678: | * over the other information (server and parameters). |
| 10679: | * |
| 10680: | * @param string $uri The URI |
| 10681: | * @param string $method The HTTP method |
| 10682: | * @param array $parameters The query (GET) or request (POST) parameters |
| 10683: | * @param array $cookies The request cookies ($_COOKIE) |
| 10684: | * @param array $files The request files ($_FILES) |
| 10685: | * @param array $server The server parameters ($_SERVER) |
| 10686: | * @param string|resource|null $content The raw body data |
| 10687: | * @static |
| 10688: | */ |
| 10689: | public static function create($uri, $method = 'GET', $parameters = [], $cookies = [], $files = [], $server = [], $content = null) |
| 10690: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10691: | return \Illuminate\Http\Request::create($uri, $method, $parameters, $cookies, $files, $server, $content); |
| 10692: | } |
| 10693: | /** |
| 10694: | * Sets a callable able to create a Request instance. |
| 10695: | * |
| 10696: | * This is mainly useful when you need to override the Request class |
| 10697: | * to keep BC with an existing system. It should not be used for any |
| 10698: | * other purpose. |
| 10699: | * |
| 10700: | * @static |
| 10701: | */ |
| 10702: | public static function setFactory($callable) |
| 10703: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10704: | return \Illuminate\Http\Request::setFactory($callable); |
| 10705: | } |
| 10706: | /** |
| 10707: | * Overrides the PHP global variables according to this request instance. |
| 10708: | * |
| 10709: | * It overrides $_GET, $_POST, $_REQUEST, $_SERVER, $_COOKIE. |
| 10710: | * $_FILES is never overridden, see rfc1867 |
| 10711: | * |
| 10712: | * @static |
| 10713: | */ |
| 10714: | public static function overrideGlobals() |
| 10715: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10716: | /** @var \Illuminate\Http\Request $instance */ |
| 10717: | return $instance->overrideGlobals(); |
| 10718: | } |
| 10719: | /** |
| 10720: | * Sets a list of trusted proxies. |
| 10721: | * |
| 10722: | * You should only list the reverse proxies that you manage directly. |
| 10723: | * |
| 10724: | * @param array $proxies A list of trusted proxies, the string 'REMOTE_ADDR' will be replaced with $_SERVER['REMOTE_ADDR'] |
| 10725: | * @param int $trustedHeaderSet A bit field of Request::HEADER_*, to set which headers to trust from your proxies |
| 10726: | * @static |
| 10727: | */ |
| 10728: | public static function setTrustedProxies($proxies, $trustedHeaderSet) |
| 10729: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10730: | return \Illuminate\Http\Request::setTrustedProxies($proxies, $trustedHeaderSet); |
| 10731: | } |
| 10732: | /** |
| 10733: | * Gets the list of trusted proxies. |
| 10734: | * |
| 10735: | * @static |
| 10736: | */ |
| 10737: | public static function getTrustedProxies() |
| 10738: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10739: | return \Illuminate\Http\Request::getTrustedProxies(); |
| 10740: | } |
| 10741: | /** |
| 10742: | * Gets the set of trusted headers from trusted proxies. |
| 10743: | * |
| 10744: | * @return int A bit field of Request::HEADER_* that defines which headers are trusted from your proxies |
| 10745: | * @static |
| 10746: | */ |
| 10747: | public static function getTrustedHeaderSet() |
| 10748: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10749: | return \Illuminate\Http\Request::getTrustedHeaderSet(); |
| 10750: | } |
| 10751: | /** |
| 10752: | * Sets a list of trusted host patterns. |
| 10753: | * |
| 10754: | * You should only list the hosts you manage using regexs. |
| 10755: | * |
| 10756: | * @param array $hostPatterns A list of trusted host patterns |
| 10757: | * @static |
| 10758: | */ |
| 10759: | public static function setTrustedHosts($hostPatterns) |
| 10760: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10761: | return \Illuminate\Http\Request::setTrustedHosts($hostPatterns); |
| 10762: | } |
| 10763: | /** |
| 10764: | * Gets the list of trusted host patterns. |
| 10765: | * |
| 10766: | * @static |
| 10767: | */ |
| 10768: | public static function getTrustedHosts() |
| 10769: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10770: | return \Illuminate\Http\Request::getTrustedHosts(); |
| 10771: | } |
| 10772: | /** |
| 10773: | * Normalizes a query string. |
| 10774: | * |
| 10775: | * It builds a normalized query string, where keys/value pairs are alphabetized, |
| 10776: | * have consistent escaping and unneeded delimiters are removed. |
| 10777: | * |
| 10778: | * @static |
| 10779: | */ |
| 10780: | public static function normalizeQueryString($qs) |
| 10781: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10782: | return \Illuminate\Http\Request::normalizeQueryString($qs); |
| 10783: | } |
| 10784: | /** |
| 10785: | * Enables support for the _method request parameter to determine the intended HTTP method. |
| 10786: | * |
| 10787: | * Be warned that enabling this feature might lead to CSRF issues in your code. |
| 10788: | * Check that you are using CSRF tokens when required. |
| 10789: | * If the HTTP method parameter override is enabled, an html-form with method "POST" can be altered |
| 10790: | * and used to send a "PUT" or "DELETE" request via the _method request parameter. |
| 10791: | * If these methods are not protected against CSRF, this presents a possible vulnerability. |
| 10792: | * |
| 10793: | * The HTTP method can only be overridden when the real HTTP method is POST. |
| 10794: | * |
| 10795: | * @static |
| 10796: | */ |
| 10797: | public static function enableHttpMethodParameterOverride() |
| 10798: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10799: | return \Illuminate\Http\Request::enableHttpMethodParameterOverride(); |
| 10800: | } |
| 10801: | /** |
| 10802: | * Checks whether support for the _method request parameter is enabled. |
| 10803: | * |
| 10804: | * @static |
| 10805: | */ |
| 10806: | public static function getHttpMethodParameterOverride() |
| 10807: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10808: | return \Illuminate\Http\Request::getHttpMethodParameterOverride(); |
| 10809: | } |
| 10810: | /** |
| 10811: | * Whether the request contains a Session which was started in one of the |
| 10812: | * previous requests. |
| 10813: | * |
| 10814: | * @static |
| 10815: | */ |
| 10816: | public static function hasPreviousSession() |
| 10817: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10818: | /** @var \Illuminate\Http\Request $instance */ |
| 10819: | return $instance->hasPreviousSession(); |
| 10820: | } |
| 10821: | /** |
| 10822: | * |
| 10823: | * |
| 10824: | * @static |
| 10825: | */ |
| 10826: | public static function setSession($session) |
| 10827: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10828: | /** @var \Illuminate\Http\Request $instance */ |
| 10829: | return $instance->setSession($session); |
| 10830: | } |
| 10831: | /** |
| 10832: | * |
| 10833: | * |
| 10834: | * @internal |
| 10835: | * @param \Symfony\Component\HttpFoundation\callable(): SessionInterface $factory |
| 10836: | * @static |
| 10837: | */ |
| 10838: | public static function setSessionFactory($factory) |
| 10839: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10840: | /** @var \Illuminate\Http\Request $instance */ |
| 10841: | return $instance->setSessionFactory($factory); |
| 10842: | } |
| 10843: | /** |
| 10844: | * Returns the client IP addresses. |
| 10845: | * |
| 10846: | * In the returned array the most trusted IP address is first, and the |
| 10847: | * least trusted one last. The "real" client IP address is the last one, |
| 10848: | * but this is also the least trusted one. Trusted proxies are stripped. |
| 10849: | * |
| 10850: | * Use this method carefully; you should use getClientIp() instead. |
| 10851: | * |
| 10852: | * @see getClientIp() |
| 10853: | * @static |
| 10854: | */ |
| 10855: | public static function getClientIps() |
| 10856: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10857: | /** @var \Illuminate\Http\Request $instance */ |
| 10858: | return $instance->getClientIps(); |
| 10859: | } |
| 10860: | /** |
| 10861: | * Returns the client IP address. |
| 10862: | * |
| 10863: | * This method can read the client IP address from the "X-Forwarded-For" header |
| 10864: | * when trusted proxies were set via "setTrustedProxies()". The "X-Forwarded-For" |
| 10865: | * header value is a comma+space separated list of IP addresses, the left-most |
| 10866: | * being the original client, and each successive proxy that passed the request |
| 10867: | * adding the IP address where it received the request from. |
| 10868: | * |
| 10869: | * If your reverse proxy uses a different header name than "X-Forwarded-For", |
| 10870: | * ("Client-Ip" for instance), configure it via the $trustedHeaderSet |
| 10871: | * argument of the Request::setTrustedProxies() method instead. |
| 10872: | * |
| 10873: | * @see getClientIps() |
| 10874: | * @see https://wikipedia.org/wiki/X-Forwarded-For |
| 10875: | * @static |
| 10876: | */ |
| 10877: | public static function getClientIp() |
| 10878: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10879: | /** @var \Illuminate\Http\Request $instance */ |
| 10880: | return $instance->getClientIp(); |
| 10881: | } |
| 10882: | /** |
| 10883: | * Returns current script name. |
| 10884: | * |
| 10885: | * @static |
| 10886: | */ |
| 10887: | public static function getScriptName() |
| 10888: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10889: | /** @var \Illuminate\Http\Request $instance */ |
| 10890: | return $instance->getScriptName(); |
| 10891: | } |
| 10892: | /** |
| 10893: | * Returns the path being requested relative to the executed script. |
| 10894: | * |
| 10895: | * The path info always starts with a /. |
| 10896: | * |
| 10897: | * Suppose this request is instantiated from /mysite on localhost: |
| 10898: | * |
| 10899: | * * http://localhost/mysite returns an empty string |
| 10900: | * * http://localhost/mysite/about returns '/about' |
| 10901: | * * http://localhost/mysite/enco%20ded returns '/enco%20ded' |
| 10902: | * * http://localhost/mysite/about?var=1 returns '/about' |
| 10903: | * |
| 10904: | * @return string The raw path (i.e. not urldecoded) |
| 10905: | * @static |
| 10906: | */ |
| 10907: | public static function getPathInfo() |
| 10908: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10909: | /** @var \Illuminate\Http\Request $instance */ |
| 10910: | return $instance->getPathInfo(); |
| 10911: | } |
| 10912: | /** |
| 10913: | * Returns the root path from which this request is executed. |
| 10914: | * |
| 10915: | * Suppose that an index.php file instantiates this request object: |
| 10916: | * |
| 10917: | * * http://localhost/index.php returns an empty string |
| 10918: | * * http://localhost/index.php/page returns an empty string |
| 10919: | * * http://localhost/web/index.php returns '/web' |
| 10920: | * * http://localhost/we%20b/index.php returns '/we%20b' |
| 10921: | * |
| 10922: | * @return string The raw path (i.e. not urldecoded) |
| 10923: | * @static |
| 10924: | */ |
| 10925: | public static function getBasePath() |
| 10926: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10927: | /** @var \Illuminate\Http\Request $instance */ |
| 10928: | return $instance->getBasePath(); |
| 10929: | } |
| 10930: | /** |
| 10931: | * Returns the root URL from which this request is executed. |
| 10932: | * |
| 10933: | * The base URL never ends with a /. |
| 10934: | * |
| 10935: | * This is similar to getBasePath(), except that it also includes the |
| 10936: | * script filename (e.g. index.php) if one exists. |
| 10937: | * |
| 10938: | * @return string The raw URL (i.e. not urldecoded) |
| 10939: | * @static |
| 10940: | */ |
| 10941: | public static function getBaseUrl() |
| 10942: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10943: | /** @var \Illuminate\Http\Request $instance */ |
| 10944: | return $instance->getBaseUrl(); |
| 10945: | } |
| 10946: | /** |
| 10947: | * Gets the request's scheme. |
| 10948: | * |
| 10949: | * @static |
| 10950: | */ |
| 10951: | public static function getScheme() |
| 10952: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10953: | /** @var \Illuminate\Http\Request $instance */ |
| 10954: | return $instance->getScheme(); |
| 10955: | } |
| 10956: | /** |
| 10957: | * Returns the port on which the request is made. |
| 10958: | * |
| 10959: | * This method can read the client port from the "X-Forwarded-Port" header |
| 10960: | * when trusted proxies were set via "setTrustedProxies()". |
| 10961: | * |
| 10962: | * The "X-Forwarded-Port" header must contain the client port. |
| 10963: | * |
| 10964: | * @return int|string|null Can be a string if fetched from the server bag |
| 10965: | * @static |
| 10966: | */ |
| 10967: | public static function getPort() |
| 10968: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10969: | /** @var \Illuminate\Http\Request $instance */ |
| 10970: | return $instance->getPort(); |
| 10971: | } |
| 10972: | /** |
| 10973: | * Returns the user. |
| 10974: | * |
| 10975: | * @static |
| 10976: | */ |
| 10977: | public static function getUser() |
| 10978: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10979: | /** @var \Illuminate\Http\Request $instance */ |
| 10980: | return $instance->getUser(); |
| 10981: | } |
| 10982: | /** |
| 10983: | * Returns the password. |
| 10984: | * |
| 10985: | * @static |
| 10986: | */ |
| 10987: | public static function getPassword() |
| 10988: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 10989: | /** @var \Illuminate\Http\Request $instance */ |
| 10990: | return $instance->getPassword(); |
| 10991: | } |
| 10992: | /** |
| 10993: | * Gets the user info. |
| 10994: | * |
| 10995: | * @return string|null A user name if any and, optionally, scheme-specific information about how to gain authorization to access the server |
| 10996: | * @static |
| 10997: | */ |
| 10998: | public static function getUserInfo() |
| 10999: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11000: | /** @var \Illuminate\Http\Request $instance */ |
| 11001: | return $instance->getUserInfo(); |
| 11002: | } |
| 11003: | /** |
| 11004: | * Returns the HTTP host being requested. |
| 11005: | * |
| 11006: | * The port name will be appended to the host if it's non-standard. |
| 11007: | * |
| 11008: | * @static |
| 11009: | */ |
| 11010: | public static function getHttpHost() |
| 11011: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11012: | /** @var \Illuminate\Http\Request $instance */ |
| 11013: | return $instance->getHttpHost(); |
| 11014: | } |
| 11015: | /** |
| 11016: | * Returns the requested URI (path and query string). |
| 11017: | * |
| 11018: | * @return string The raw URI (i.e. not URI decoded) |
| 11019: | * @static |
| 11020: | */ |
| 11021: | public static function getRequestUri() |
| 11022: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11023: | /** @var \Illuminate\Http\Request $instance */ |
| 11024: | return $instance->getRequestUri(); |
| 11025: | } |
| 11026: | /** |
| 11027: | * Gets the scheme and HTTP host. |
| 11028: | * |
| 11029: | * If the URL was called with basic authentication, the user |
| 11030: | * and the password are not added to the generated string. |
| 11031: | * |
| 11032: | * @static |
| 11033: | */ |
| 11034: | public static function getSchemeAndHttpHost() |
| 11035: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11036: | /** @var \Illuminate\Http\Request $instance */ |
| 11037: | return $instance->getSchemeAndHttpHost(); |
| 11038: | } |
| 11039: | /** |
| 11040: | * Generates a normalized URI (URL) for the Request. |
| 11041: | * |
| 11042: | * @see getQueryString() |
| 11043: | * @static |
| 11044: | */ |
| 11045: | public static function getUri() |
| 11046: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11047: | /** @var \Illuminate\Http\Request $instance */ |
| 11048: | return $instance->getUri(); |
| 11049: | } |
| 11050: | /** |
| 11051: | * Generates a normalized URI for the given path. |
| 11052: | * |
| 11053: | * @param string $path A path to use instead of the current one |
| 11054: | * @static |
| 11055: | */ |
| 11056: | public static function getUriForPath($path) |
| 11057: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11058: | /** @var \Illuminate\Http\Request $instance */ |
| 11059: | return $instance->getUriForPath($path); |
| 11060: | } |
| 11061: | /** |
| 11062: | * Returns the path as relative reference from the current Request path. |
| 11063: | * |
| 11064: | * Only the URIs path component (no schema, host etc.) is relevant and must be given. |
| 11065: | * Both paths must be absolute and not contain relative parts. |
| 11066: | * Relative URLs from one resource to another are useful when generating self-contained downloadable document archives. |
| 11067: | * Furthermore, they can be used to reduce the link size in documents. |
| 11068: | * |
| 11069: | * Example target paths, given a base path of "/a/b/c/d": |
| 11070: | * - "/a/b/c/d" -> "" |
| 11071: | * - "/a/b/c/" -> "./" |
| 11072: | * - "/a/b/" -> "../" |
| 11073: | * - "/a/b/c/other" -> "other" |
| 11074: | * - "/a/x/y" -> "../../x/y" |
| 11075: | * |
| 11076: | * @static |
| 11077: | */ |
| 11078: | public static function getRelativeUriForPath($path) |
| 11079: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11080: | /** @var \Illuminate\Http\Request $instance */ |
| 11081: | return $instance->getRelativeUriForPath($path); |
| 11082: | } |
| 11083: | /** |
| 11084: | * Generates the normalized query string for the Request. |
| 11085: | * |
| 11086: | * It builds a normalized query string, where keys/value pairs are alphabetized |
| 11087: | * and have consistent escaping. |
| 11088: | * |
| 11089: | * @static |
| 11090: | */ |
| 11091: | public static function getQueryString() |
| 11092: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11093: | /** @var \Illuminate\Http\Request $instance */ |
| 11094: | return $instance->getQueryString(); |
| 11095: | } |
| 11096: | /** |
| 11097: | * Checks whether the request is secure or not. |
| 11098: | * |
| 11099: | * This method can read the client protocol from the "X-Forwarded-Proto" header |
| 11100: | * when trusted proxies were set via "setTrustedProxies()". |
| 11101: | * |
| 11102: | * The "X-Forwarded-Proto" header must contain the protocol: "https" or "http". |
| 11103: | * |
| 11104: | * @static |
| 11105: | */ |
| 11106: | public static function isSecure() |
| 11107: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11108: | /** @var \Illuminate\Http\Request $instance */ |
| 11109: | return $instance->isSecure(); |
| 11110: | } |
| 11111: | /** |
| 11112: | * Returns the host name. |
| 11113: | * |
| 11114: | * This method can read the client host name from the "X-Forwarded-Host" header |
| 11115: | * when trusted proxies were set via "setTrustedProxies()". |
| 11116: | * |
| 11117: | * The "X-Forwarded-Host" header must contain the client host name. |
| 11118: | * |
| 11119: | * @throws SuspiciousOperationException when the host name is invalid or not trusted |
| 11120: | * @static |
| 11121: | */ |
| 11122: | public static function getHost() |
| 11123: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11124: | /** @var \Illuminate\Http\Request $instance */ |
| 11125: | return $instance->getHost(); |
| 11126: | } |
| 11127: | /** |
| 11128: | * Sets the request method. |
| 11129: | * |
| 11130: | * @static |
| 11131: | */ |
| 11132: | public static function setMethod($method) |
| 11133: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11134: | /** @var \Illuminate\Http\Request $instance */ |
| 11135: | return $instance->setMethod($method); |
| 11136: | } |
| 11137: | /** |
| 11138: | * Gets the request "intended" method. |
| 11139: | * |
| 11140: | * If the X-HTTP-Method-Override header is set, and if the method is a POST, |
| 11141: | * then it is used to determine the "real" intended HTTP method. |
| 11142: | * |
| 11143: | * The _method request parameter can also be used to determine the HTTP method, |
| 11144: | * but only if enableHttpMethodParameterOverride() has been called. |
| 11145: | * |
| 11146: | * The method is always an uppercased string. |
| 11147: | * |
| 11148: | * @see getRealMethod() |
| 11149: | * @static |
| 11150: | */ |
| 11151: | public static function getMethod() |
| 11152: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11153: | /** @var \Illuminate\Http\Request $instance */ |
| 11154: | return $instance->getMethod(); |
| 11155: | } |
| 11156: | /** |
| 11157: | * Gets the "real" request method. |
| 11158: | * |
| 11159: | * @see getMethod() |
| 11160: | * @static |
| 11161: | */ |
| 11162: | public static function getRealMethod() |
| 11163: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11164: | /** @var \Illuminate\Http\Request $instance */ |
| 11165: | return $instance->getRealMethod(); |
| 11166: | } |
| 11167: | /** |
| 11168: | * Gets the mime type associated with the format. |
| 11169: | * |
| 11170: | * @static |
| 11171: | */ |
| 11172: | public static function getMimeType($format) |
| 11173: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11174: | /** @var \Illuminate\Http\Request $instance */ |
| 11175: | return $instance->getMimeType($format); |
| 11176: | } |
| 11177: | /** |
| 11178: | * Gets the mime types associated with the format. |
| 11179: | * |
| 11180: | * @static |
| 11181: | */ |
| 11182: | public static function getMimeTypes($format) |
| 11183: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11184: | return \Illuminate\Http\Request::getMimeTypes($format); |
| 11185: | } |
| 11186: | /** |
| 11187: | * Gets the format associated with the mime type. |
| 11188: | * |
| 11189: | * @static |
| 11190: | */ |
| 11191: | public static function getFormat($mimeType) |
| 11192: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11193: | /** @var \Illuminate\Http\Request $instance */ |
| 11194: | return $instance->getFormat($mimeType); |
| 11195: | } |
| 11196: | /** |
| 11197: | * Associates a format with mime types. |
| 11198: | * |
| 11199: | * @param string|array $mimeTypes The associated mime types (the preferred one must be the first as it will be used as the content type) |
| 11200: | * @static |
| 11201: | */ |
| 11202: | public static function setFormat($format, $mimeTypes) |
| 11203: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11204: | /** @var \Illuminate\Http\Request $instance */ |
| 11205: | return $instance->setFormat($format, $mimeTypes); |
| 11206: | } |
| 11207: | /** |
| 11208: | * Gets the request format. |
| 11209: | * |
| 11210: | * Here is the process to determine the format: |
| 11211: | * |
| 11212: | * * format defined by the user (with setRequestFormat()) |
| 11213: | * * _format request attribute |
| 11214: | * * $default |
| 11215: | * |
| 11216: | * @see getPreferredFormat |
| 11217: | * @static |
| 11218: | */ |
| 11219: | public static function getRequestFormat($default = 'html') |
| 11220: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11221: | /** @var \Illuminate\Http\Request $instance */ |
| 11222: | return $instance->getRequestFormat($default); |
| 11223: | } |
| 11224: | /** |
| 11225: | * Sets the request format. |
| 11226: | * |
| 11227: | * @static |
| 11228: | */ |
| 11229: | public static function setRequestFormat($format) |
| 11230: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11231: | /** @var \Illuminate\Http\Request $instance */ |
| 11232: | return $instance->setRequestFormat($format); |
| 11233: | } |
| 11234: | /** |
| 11235: | * Gets the format associated with the request. |
| 11236: | * |
| 11237: | * @static |
| 11238: | */ |
| 11239: | public static function getContentType() |
| 11240: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11241: | /** @var \Illuminate\Http\Request $instance */ |
| 11242: | return $instance->getContentType(); |
| 11243: | } |
| 11244: | /** |
| 11245: | * Sets the default locale. |
| 11246: | * |
| 11247: | * @static |
| 11248: | */ |
| 11249: | public static function setDefaultLocale($locale) |
| 11250: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11251: | /** @var \Illuminate\Http\Request $instance */ |
| 11252: | return $instance->setDefaultLocale($locale); |
| 11253: | } |
| 11254: | /** |
| 11255: | * Get the default locale. |
| 11256: | * |
| 11257: | * @static |
| 11258: | */ |
| 11259: | public static function getDefaultLocale() |
| 11260: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11261: | /** @var \Illuminate\Http\Request $instance */ |
| 11262: | return $instance->getDefaultLocale(); |
| 11263: | } |
| 11264: | /** |
| 11265: | * Sets the locale. |
| 11266: | * |
| 11267: | * @static |
| 11268: | */ |
| 11269: | public static function setLocale($locale) |
| 11270: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11271: | /** @var \Illuminate\Http\Request $instance */ |
| 11272: | return $instance->setLocale($locale); |
| 11273: | } |
| 11274: | /** |
| 11275: | * Get the locale. |
| 11276: | * |
| 11277: | * @static |
| 11278: | */ |
| 11279: | public static function getLocale() |
| 11280: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11281: | /** @var \Illuminate\Http\Request $instance */ |
| 11282: | return $instance->getLocale(); |
| 11283: | } |
| 11284: | /** |
| 11285: | * Checks if the request method is of specified type. |
| 11286: | * |
| 11287: | * @param string $method Uppercase request method (GET, POST etc) |
| 11288: | * @static |
| 11289: | */ |
| 11290: | public static function isMethod($method) |
| 11291: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11292: | /** @var \Illuminate\Http\Request $instance */ |
| 11293: | return $instance->isMethod($method); |
| 11294: | } |
| 11295: | /** |
| 11296: | * Checks whether or not the method is safe. |
| 11297: | * |
| 11298: | * @see https://tools.ietf.org/html/rfc7231#section-4.2.1 |
| 11299: | * @static |
| 11300: | */ |
| 11301: | public static function isMethodSafe() |
| 11302: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11303: | /** @var \Illuminate\Http\Request $instance */ |
| 11304: | return $instance->isMethodSafe(); |
| 11305: | } |
| 11306: | /** |
| 11307: | * Checks whether or not the method is idempotent. |
| 11308: | * |
| 11309: | * @static |
| 11310: | */ |
| 11311: | public static function isMethodIdempotent() |
| 11312: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11313: | /** @var \Illuminate\Http\Request $instance */ |
| 11314: | return $instance->isMethodIdempotent(); |
| 11315: | } |
| 11316: | /** |
| 11317: | * Checks whether the method is cacheable or not. |
| 11318: | * |
| 11319: | * @see https://tools.ietf.org/html/rfc7231#section-4.2.3 |
| 11320: | * @static |
| 11321: | */ |
| 11322: | public static function isMethodCacheable() |
| 11323: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11324: | /** @var \Illuminate\Http\Request $instance */ |
| 11325: | return $instance->isMethodCacheable(); |
| 11326: | } |
| 11327: | /** |
| 11328: | * Returns the protocol version. |
| 11329: | * |
| 11330: | * If the application is behind a proxy, the protocol version used in the |
| 11331: | * requests between the client and the proxy and between the proxy and the |
| 11332: | * server might be different. This returns the former (from the "Via" header) |
| 11333: | * if the proxy is trusted (see "setTrustedProxies()"), otherwise it returns |
| 11334: | * the latter (from the "SERVER_PROTOCOL" server parameter). |
| 11335: | * |
| 11336: | * @static |
| 11337: | */ |
| 11338: | public static function getProtocolVersion() |
| 11339: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11340: | /** @var \Illuminate\Http\Request $instance */ |
| 11341: | return $instance->getProtocolVersion(); |
| 11342: | } |
| 11343: | /** |
| 11344: | * Returns the request body content. |
| 11345: | * |
| 11346: | * @param bool $asResource If true, a resource will be returned |
| 11347: | * @return string|resource |
| 11348: | * @static |
| 11349: | */ |
| 11350: | public static function getContent($asResource = false) |
| 11351: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11352: | /** @var \Illuminate\Http\Request $instance */ |
| 11353: | return $instance->getContent($asResource); |
| 11354: | } |
| 11355: | /** |
| 11356: | * Gets the Etags. |
| 11357: | * |
| 11358: | * @static |
| 11359: | */ |
| 11360: | public static function getETags() |
| 11361: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11362: | /** @var \Illuminate\Http\Request $instance */ |
| 11363: | return $instance->getETags(); |
| 11364: | } |
| 11365: | /** |
| 11366: | * |
| 11367: | * |
| 11368: | * @static |
| 11369: | */ |
| 11370: | public static function isNoCache() |
| 11371: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11372: | /** @var \Illuminate\Http\Request $instance */ |
| 11373: | return $instance->isNoCache(); |
| 11374: | } |
| 11375: | /** |
| 11376: | * Gets the preferred format for the response by inspecting, in the following order: |
| 11377: | * * the request format set using setRequestFormat; |
| 11378: | * * the values of the Accept HTTP header. |
| 11379: | * |
| 11380: | * Note that if you use this method, you should send the "Vary: Accept" header |
| 11381: | * in the response to prevent any issues with intermediary HTTP caches. |
| 11382: | * |
| 11383: | * @static |
| 11384: | */ |
| 11385: | public static function getPreferredFormat($default = 'html') |
| 11386: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11387: | /** @var \Illuminate\Http\Request $instance */ |
| 11388: | return $instance->getPreferredFormat($default); |
| 11389: | } |
| 11390: | /** |
| 11391: | * Returns the preferred language. |
| 11392: | * |
| 11393: | * @param string[] $locales An array of ordered available locales |
| 11394: | * @static |
| 11395: | */ |
| 11396: | public static function getPreferredLanguage($locales = null) |
| 11397: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11398: | /** @var \Illuminate\Http\Request $instance */ |
| 11399: | return $instance->getPreferredLanguage($locales); |
| 11400: | } |
| 11401: | /** |
| 11402: | * Gets a list of languages acceptable by the client browser ordered in the user browser preferences. |
| 11403: | * |
| 11404: | * @static |
| 11405: | */ |
| 11406: | public static function getLanguages() |
| 11407: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11408: | /** @var \Illuminate\Http\Request $instance */ |
| 11409: | return $instance->getLanguages(); |
| 11410: | } |
| 11411: | /** |
| 11412: | * Gets a list of charsets acceptable by the client browser in preferable order. |
| 11413: | * |
| 11414: | * @static |
| 11415: | */ |
| 11416: | public static function getCharsets() |
| 11417: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11418: | /** @var \Illuminate\Http\Request $instance */ |
| 11419: | return $instance->getCharsets(); |
| 11420: | } |
| 11421: | /** |
| 11422: | * Gets a list of encodings acceptable by the client browser in preferable order. |
| 11423: | * |
| 11424: | * @static |
| 11425: | */ |
| 11426: | public static function getEncodings() |
| 11427: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11428: | /** @var \Illuminate\Http\Request $instance */ |
| 11429: | return $instance->getEncodings(); |
| 11430: | } |
| 11431: | /** |
| 11432: | * Gets a list of content types acceptable by the client browser in preferable order. |
| 11433: | * |
| 11434: | * @static |
| 11435: | */ |
| 11436: | public static function getAcceptableContentTypes() |
| 11437: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11438: | /** @var \Illuminate\Http\Request $instance */ |
| 11439: | return $instance->getAcceptableContentTypes(); |
| 11440: | } |
| 11441: | /** |
| 11442: | * Returns true if the request is an XMLHttpRequest. |
| 11443: | * |
| 11444: | * It works if your JavaScript library sets an X-Requested-With HTTP header. |
| 11445: | * It is known to work with common JavaScript frameworks: |
| 11446: | * |
| 11447: | * @see https://wikipedia.org/wiki/List_of_Ajax_frameworks#JavaScript |
| 11448: | * @static |
| 11449: | */ |
| 11450: | public static function isXmlHttpRequest() |
| 11451: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11452: | /** @var \Illuminate\Http\Request $instance */ |
| 11453: | return $instance->isXmlHttpRequest(); |
| 11454: | } |
| 11455: | /** |
| 11456: | * Checks whether the client browser prefers safe content or not according to RFC8674. |
| 11457: | * |
| 11458: | * @see https://tools.ietf.org/html/rfc8674 |
| 11459: | * @static |
| 11460: | */ |
| 11461: | public static function preferSafeContent() |
| 11462: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11463: | /** @var \Illuminate\Http\Request $instance */ |
| 11464: | return $instance->preferSafeContent(); |
| 11465: | } |
| 11466: | /** |
| 11467: | * Indicates whether this request originated from a trusted proxy. |
| 11468: | * |
| 11469: | * This can be useful to determine whether or not to trust the |
| 11470: | * contents of a proxy-specific header. |
| 11471: | * |
| 11472: | * @static |
| 11473: | */ |
| 11474: | public static function isFromTrustedProxy() |
| 11475: | { //Method inherited from \Symfony\Component\HttpFoundation\Request |
| 11476: | /** @var \Illuminate\Http\Request $instance */ |
| 11477: | return $instance->isFromTrustedProxy(); |
| 11478: | } |
| 11479: | /** |
| 11480: | * Determine if the request is sending JSON. |
| 11481: | * |
| 11482: | * @return bool |
| 11483: | * @static |
| 11484: | */ |
| 11485: | public static function isJson() |
| 11486: | { |
| 11487: | /** @var \Illuminate\Http\Request $instance */ |
| 11488: | return $instance->isJson(); |
| 11489: | } |
| 11490: | /** |
| 11491: | * Determine if the current request probably expects a JSON response. |
| 11492: | * |
| 11493: | * @return bool |
| 11494: | * @static |
| 11495: | */ |
| 11496: | public static function expectsJson() |
| 11497: | { |
| 11498: | /** @var \Illuminate\Http\Request $instance */ |
| 11499: | return $instance->expectsJson(); |
| 11500: | } |
| 11501: | /** |
| 11502: | * Determine if the current request is asking for JSON. |
| 11503: | * |
| 11504: | * @return bool |
| 11505: | * @static |
| 11506: | */ |
| 11507: | public static function wantsJson() |
| 11508: | { |
| 11509: | /** @var \Illuminate\Http\Request $instance */ |
| 11510: | return $instance->wantsJson(); |
| 11511: | } |
| 11512: | /** |
| 11513: | * Determines whether the current requests accepts a given content type. |
| 11514: | * |
| 11515: | * @param string|array $contentTypes |
| 11516: | * @return bool |
| 11517: | * @static |
| 11518: | */ |
| 11519: | public static function accepts($contentTypes) |
| 11520: | { |
| 11521: | /** @var \Illuminate\Http\Request $instance */ |
| 11522: | return $instance->accepts($contentTypes); |
| 11523: | } |
| 11524: | /** |
| 11525: | * Return the most suitable content type from the given array based on content negotiation. |
| 11526: | * |
| 11527: | * @param string|array $contentTypes |
| 11528: | * @return string|null |
| 11529: | * @static |
| 11530: | */ |
| 11531: | public static function prefers($contentTypes) |
| 11532: | { |
| 11533: | /** @var \Illuminate\Http\Request $instance */ |
| 11534: | return $instance->prefers($contentTypes); |
| 11535: | } |
| 11536: | /** |
| 11537: | * Determine if the current request accepts any content type. |
| 11538: | * |
| 11539: | * @return bool |
| 11540: | * @static |
| 11541: | */ |
| 11542: | public static function acceptsAnyContentType() |
| 11543: | { |
| 11544: | /** @var \Illuminate\Http\Request $instance */ |
| 11545: | return $instance->acceptsAnyContentType(); |
| 11546: | } |
| 11547: | /** |
| 11548: | * Determines whether a request accepts JSON. |
| 11549: | * |
| 11550: | * @return bool |
| 11551: | * @static |
| 11552: | */ |
| 11553: | public static function acceptsJson() |
| 11554: | { |
| 11555: | /** @var \Illuminate\Http\Request $instance */ |
| 11556: | return $instance->acceptsJson(); |
| 11557: | } |
| 11558: | /** |
| 11559: | * Determines whether a request accepts HTML. |
| 11560: | * |
| 11561: | * @return bool |
| 11562: | * @static |
| 11563: | */ |
| 11564: | public static function acceptsHtml() |
| 11565: | { |
| 11566: | /** @var \Illuminate\Http\Request $instance */ |
| 11567: | return $instance->acceptsHtml(); |
| 11568: | } |
| 11569: | /** |
| 11570: | * Determine if the given content types match. |
| 11571: | * |
| 11572: | * @param string $actual |
| 11573: | * @param string $type |
| 11574: | * @return bool |
| 11575: | * @static |
| 11576: | */ |
| 11577: | public static function matchesType($actual, $type) |
| 11578: | { |
| 11579: | return \Illuminate\Http\Request::matchesType($actual, $type); |
| 11580: | } |
| 11581: | /** |
| 11582: | * Get the data format expected in the response. |
| 11583: | * |
| 11584: | * @param string $default |
| 11585: | * @return string |
| 11586: | * @static |
| 11587: | */ |
| 11588: | public static function format($default = 'html') |
| 11589: | { |
| 11590: | /** @var \Illuminate\Http\Request $instance */ |
| 11591: | return $instance->format($default); |
| 11592: | } |
| 11593: | /** |
| 11594: | * Retrieve an old input item. |
| 11595: | * |
| 11596: | * @param string|null $key |
| 11597: | * @param \Illuminate\Database\Eloquent\Model|string|array|null $default |
| 11598: | * @return string|array|null |
| 11599: | * @static |
| 11600: | */ |
| 11601: | public static function old($key = null, $default = null) |
| 11602: | { |
| 11603: | /** @var \Illuminate\Http\Request $instance */ |
| 11604: | return $instance->old($key, $default); |
| 11605: | } |
| 11606: | /** |
| 11607: | * Flash the input for the current request to the session. |
| 11608: | * |
| 11609: | * @return void |
| 11610: | * @static |
| 11611: | */ |
| 11612: | public static function flash() |
| 11613: | { |
| 11614: | /** @var \Illuminate\Http\Request $instance */ |
| 11615: | $instance->flash(); |
| 11616: | } |
| 11617: | /** |
| 11618: | * Flash only some of the input to the session. |
| 11619: | * |
| 11620: | * @param array|mixed $keys |
| 11621: | * @return void |
| 11622: | * @static |
| 11623: | */ |
| 11624: | public static function flashOnly($keys) |
| 11625: | { |
| 11626: | /** @var \Illuminate\Http\Request $instance */ |
| 11627: | $instance->flashOnly($keys); |
| 11628: | } |
| 11629: | /** |
| 11630: | * Flash only some of the input to the session. |
| 11631: | * |
| 11632: | * @param array|mixed $keys |
| 11633: | * @return void |
| 11634: | * @static |
| 11635: | */ |
| 11636: | public static function flashExcept($keys) |
| 11637: | { |
| 11638: | /** @var \Illuminate\Http\Request $instance */ |
| 11639: | $instance->flashExcept($keys); |
| 11640: | } |
| 11641: | /** |
| 11642: | * Flush all of the old input from the session. |
| 11643: | * |
| 11644: | * @return void |
| 11645: | * @static |
| 11646: | */ |
| 11647: | public static function flush() |
| 11648: | { |
| 11649: | /** @var \Illuminate\Http\Request $instance */ |
| 11650: | $instance->flush(); |
| 11651: | } |
| 11652: | /** |
| 11653: | * Retrieve a server variable from the request. |
| 11654: | * |
| 11655: | * @param string|null $key |
| 11656: | * @param string|array|null $default |
| 11657: | * @return string|array|null |
| 11658: | * @static |
| 11659: | */ |
| 11660: | public static function server($key = null, $default = null) |
| 11661: | { |
| 11662: | /** @var \Illuminate\Http\Request $instance */ |
| 11663: | return $instance->server($key, $default); |
| 11664: | } |
| 11665: | /** |
| 11666: | * Determine if a header is set on the request. |
| 11667: | * |
| 11668: | * @param string $key |
| 11669: | * @return bool |
| 11670: | * @static |
| 11671: | */ |
| 11672: | public static function hasHeader($key) |
| 11673: | { |
| 11674: | /** @var \Illuminate\Http\Request $instance */ |
| 11675: | return $instance->hasHeader($key); |
| 11676: | } |
| 11677: | /** |
| 11678: | * Retrieve a header from the request. |
| 11679: | * |
| 11680: | * @param string|null $key |
| 11681: | * @param string|array|null $default |
| 11682: | * @return string|array|null |
| 11683: | * @static |
| 11684: | */ |
| 11685: | public static function header($key = null, $default = null) |
| 11686: | { |
| 11687: | /** @var \Illuminate\Http\Request $instance */ |
| 11688: | return $instance->header($key, $default); |
| 11689: | } |
| 11690: | /** |
| 11691: | * Get the bearer token from the request headers. |
| 11692: | * |
| 11693: | * @return string|null |
| 11694: | * @static |
| 11695: | */ |
| 11696: | public static function bearerToken() |
| 11697: | { |
| 11698: | /** @var \Illuminate\Http\Request $instance */ |
| 11699: | return $instance->bearerToken(); |
| 11700: | } |
| 11701: | /** |
| 11702: | * Determine if the request contains a given input item key. |
| 11703: | * |
| 11704: | * @param string|array $key |
| 11705: | * @return bool |
| 11706: | * @static |
| 11707: | */ |
| 11708: | public static function exists($key) |
| 11709: | { |
| 11710: | /** @var \Illuminate\Http\Request $instance */ |
| 11711: | return $instance->exists($key); |
| 11712: | } |
| 11713: | /** |
| 11714: | * Determine if the request contains a given input item key. |
| 11715: | * |
| 11716: | * @param string|array $key |
| 11717: | * @return bool |
| 11718: | * @static |
| 11719: | */ |
| 11720: | public static function has($key) |
| 11721: | { |
| 11722: | /** @var \Illuminate\Http\Request $instance */ |
| 11723: | return $instance->has($key); |
| 11724: | } |
| 11725: | /** |
| 11726: | * Determine if the request contains any of the given inputs. |
| 11727: | * |
| 11728: | * @param string|array $keys |
| 11729: | * @return bool |
| 11730: | * @static |
| 11731: | */ |
| 11732: | public static function hasAny($keys) |
| 11733: | { |
| 11734: | /** @var \Illuminate\Http\Request $instance */ |
| 11735: | return $instance->hasAny($keys); |
| 11736: | } |
| 11737: | /** |
| 11738: | * Apply the callback if the request contains the given input item key. |
| 11739: | * |
| 11740: | * @param string $key |
| 11741: | * @param callable $callback |
| 11742: | * @param callable|null $default |
| 11743: | * @return $this|mixed |
| 11744: | * @static |
| 11745: | */ |
| 11746: | public static function whenHas($key, $callback, $default = null) |
| 11747: | { |
| 11748: | /** @var \Illuminate\Http\Request $instance */ |
| 11749: | return $instance->whenHas($key, $callback, $default); |
| 11750: | } |
| 11751: | /** |
| 11752: | * Determine if the request contains a non-empty value for an input item. |
| 11753: | * |
| 11754: | * @param string|array $key |
| 11755: | * @return bool |
| 11756: | * @static |
| 11757: | */ |
| 11758: | public static function filled($key) |
| 11759: | { |
| 11760: | /** @var \Illuminate\Http\Request $instance */ |
| 11761: | return $instance->filled($key); |
| 11762: | } |
| 11763: | /** |
| 11764: | * Determine if the request contains an empty value for an input item. |
| 11765: | * |
| 11766: | * @param string|array $key |
| 11767: | * @return bool |
| 11768: | * @static |
| 11769: | */ |
| 11770: | public static function isNotFilled($key) |
| 11771: | { |
| 11772: | /** @var \Illuminate\Http\Request $instance */ |
| 11773: | return $instance->isNotFilled($key); |
| 11774: | } |
| 11775: | /** |
| 11776: | * Determine if the request contains a non-empty value for any of the given inputs. |
| 11777: | * |
| 11778: | * @param string|array $keys |
| 11779: | * @return bool |
| 11780: | * @static |
| 11781: | */ |
| 11782: | public static function anyFilled($keys) |
| 11783: | { |
| 11784: | /** @var \Illuminate\Http\Request $instance */ |
| 11785: | return $instance->anyFilled($keys); |
| 11786: | } |
| 11787: | /** |
| 11788: | * Apply the callback if the request contains a non-empty value for the given input item key. |
| 11789: | * |
| 11790: | * @param string $key |
| 11791: | * @param callable $callback |
| 11792: | * @param callable|null $default |
| 11793: | * @return $this|mixed |
| 11794: | * @static |
| 11795: | */ |
| 11796: | public static function whenFilled($key, $callback, $default = null) |
| 11797: | { |
| 11798: | /** @var \Illuminate\Http\Request $instance */ |
| 11799: | return $instance->whenFilled($key, $callback, $default); |
| 11800: | } |
| 11801: | /** |
| 11802: | * Determine if the request is missing a given input item key. |
| 11803: | * |
| 11804: | * @param string|array $key |
| 11805: | * @return bool |
| 11806: | * @static |
| 11807: | */ |
| 11808: | public static function missing($key) |
| 11809: | { |
| 11810: | /** @var \Illuminate\Http\Request $instance */ |
| 11811: | return $instance->missing($key); |
| 11812: | } |
| 11813: | /** |
| 11814: | * Get the keys for all of the input and files. |
| 11815: | * |
| 11816: | * @return array |
| 11817: | * @static |
| 11818: | */ |
| 11819: | public static function keys() |
| 11820: | { |
| 11821: | /** @var \Illuminate\Http\Request $instance */ |
| 11822: | return $instance->keys(); |
| 11823: | } |
| 11824: | /** |
| 11825: | * Get all of the input and files for the request. |
| 11826: | * |
| 11827: | * @param array|mixed|null $keys |
| 11828: | * @return array |
| 11829: | * @static |
| 11830: | */ |
| 11831: | public static function all($keys = null) |
| 11832: | { |
| 11833: | /** @var \Illuminate\Http\Request $instance */ |
| 11834: | return $instance->all($keys); |
| 11835: | } |
| 11836: | /** |
| 11837: | * Retrieve an input item from the request. |
| 11838: | * |
| 11839: | * @param string|null $key |
| 11840: | * @param mixed $default |
| 11841: | * @return mixed |
| 11842: | * @static |
| 11843: | */ |
| 11844: | public static function input($key = null, $default = null) |
| 11845: | { |
| 11846: | /** @var \Illuminate\Http\Request $instance */ |
| 11847: | return $instance->input($key, $default); |
| 11848: | } |
| 11849: | /** |
| 11850: | * Retrieve input from the request as a Stringable instance. |
| 11851: | * |
| 11852: | * @param string $key |
| 11853: | * @param mixed $default |
| 11854: | * @return \Illuminate\Support\Stringable |
| 11855: | * @static |
| 11856: | */ |
| 11857: | public static function str($key, $default = null) |
| 11858: | { |
| 11859: | /** @var \Illuminate\Http\Request $instance */ |
| 11860: | return $instance->str($key, $default); |
| 11861: | } |
| 11862: | /** |
| 11863: | * Retrieve input from the request as a Stringable instance. |
| 11864: | * |
| 11865: | * @param string $key |
| 11866: | * @param mixed $default |
| 11867: | * @return \Illuminate\Support\Stringable |
| 11868: | * @static |
| 11869: | */ |
| 11870: | public static function string($key, $default = null) |
| 11871: | { |
| 11872: | /** @var \Illuminate\Http\Request $instance */ |
| 11873: | return $instance->string($key, $default); |
| 11874: | } |
| 11875: | /** |
| 11876: | * Retrieve input as a boolean value. |
| 11877: | * |
| 11878: | * Returns true when value is "1", "true", "on", and "yes". Otherwise, returns false. |
| 11879: | * |
| 11880: | * @param string|null $key |
| 11881: | * @param bool $default |
| 11882: | * @return bool |
| 11883: | * @static |
| 11884: | */ |
| 11885: | public static function boolean($key = null, $default = false) |
| 11886: | { |
| 11887: | /** @var \Illuminate\Http\Request $instance */ |
| 11888: | return $instance->boolean($key, $default); |
| 11889: | } |
| 11890: | /** |
| 11891: | * Retrieve input from the request as a Carbon instance. |
| 11892: | * |
| 11893: | * @param string $key |
| 11894: | * @param string|null $format |
| 11895: | * @param string|null $tz |
| 11896: | * @return \Illuminate\Support\Carbon|null |
| 11897: | * @static |
| 11898: | */ |
| 11899: | public static function date($key, $format = null, $tz = null) |
| 11900: | { |
| 11901: | /** @var \Illuminate\Http\Request $instance */ |
| 11902: | return $instance->date($key, $format, $tz); |
| 11903: | } |
| 11904: | /** |
| 11905: | * Retrieve input from the request as an enum. |
| 11906: | * |
| 11907: | * @param string $key |
| 11908: | * @param string $enumClass |
| 11909: | * @return mixed|null |
| 11910: | * @static |
| 11911: | */ |
| 11912: | public static function enum($key, $enumClass) |
| 11913: | { |
| 11914: | /** @var \Illuminate\Http\Request $instance */ |
| 11915: | return $instance->enum($key, $enumClass); |
| 11916: | } |
| 11917: | /** |
| 11918: | * Retrieve input from the request as a collection. |
| 11919: | * |
| 11920: | * @param array|string|null $key |
| 11921: | * @return \Illuminate\Support\Collection |
| 11922: | * @static |
| 11923: | */ |
| 11924: | public static function collect($key = null) |
| 11925: | { |
| 11926: | /** @var \Illuminate\Http\Request $instance */ |
| 11927: | return $instance->collect($key); |
| 11928: | } |
| 11929: | /** |
| 11930: | * Get a subset containing the provided keys with values from the input data. |
| 11931: | * |
| 11932: | * @param array|mixed $keys |
| 11933: | * @return array |
| 11934: | * @static |
| 11935: | */ |
| 11936: | public static function only($keys) |
| 11937: | { |
| 11938: | /** @var \Illuminate\Http\Request $instance */ |
| 11939: | return $instance->only($keys); |
| 11940: | } |
| 11941: | /** |
| 11942: | * Get all of the input except for a specified array of items. |
| 11943: | * |
| 11944: | * @param array|mixed $keys |
| 11945: | * @return array |
| 11946: | * @static |
| 11947: | */ |
| 11948: | public static function except($keys) |
| 11949: | { |
| 11950: | /** @var \Illuminate\Http\Request $instance */ |
| 11951: | return $instance->except($keys); |
| 11952: | } |
| 11953: | /** |
| 11954: | * Retrieve a query string item from the request. |
| 11955: | * |
| 11956: | * @param string|null $key |
| 11957: | * @param string|array|null $default |
| 11958: | * @return string|array|null |
| 11959: | * @static |
| 11960: | */ |
| 11961: | public static function query($key = null, $default = null) |
| 11962: | { |
| 11963: | /** @var \Illuminate\Http\Request $instance */ |
| 11964: | return $instance->query($key, $default); |
| 11965: | } |
| 11966: | /** |
| 11967: | * Retrieve a request payload item from the request. |
| 11968: | * |
| 11969: | * @param string|null $key |
| 11970: | * @param string|array|null $default |
| 11971: | * @return string|array|null |
| 11972: | * @static |
| 11973: | */ |
| 11974: | public static function post($key = null, $default = null) |
| 11975: | { |
| 11976: | /** @var \Illuminate\Http\Request $instance */ |
| 11977: | return $instance->post($key, $default); |
| 11978: | } |
| 11979: | /** |
| 11980: | * Determine if a cookie is set on the request. |
| 11981: | * |
| 11982: | * @param string $key |
| 11983: | * @return bool |
| 11984: | * @static |
| 11985: | */ |
| 11986: | public static function hasCookie($key) |
| 11987: | { |
| 11988: | /** @var \Illuminate\Http\Request $instance */ |
| 11989: | return $instance->hasCookie($key); |
| 11990: | } |
| 11991: | /** |
| 11992: | * Retrieve a cookie from the request. |
| 11993: | * |
| 11994: | * @param string|null $key |
| 11995: | * @param string|array|null $default |
| 11996: | * @return string|array|null |
| 11997: | * @static |
| 11998: | */ |
| 11999: | public static function cookie($key = null, $default = null) |
| 12000: | { |
| 12001: | /** @var \Illuminate\Http\Request $instance */ |
| 12002: | return $instance->cookie($key, $default); |
| 12003: | } |
| 12004: | /** |
| 12005: | * Get an array of all of the files on the request. |
| 12006: | * |
| 12007: | * @return array |
| 12008: | * @static |
| 12009: | */ |
| 12010: | public static function allFiles() |
| 12011: | { |
| 12012: | /** @var \Illuminate\Http\Request $instance */ |
| 12013: | return $instance->allFiles(); |
| 12014: | } |
| 12015: | /** |
| 12016: | * Determine if the uploaded data contains a file. |
| 12017: | * |
| 12018: | * @param string $key |
| 12019: | * @return bool |
| 12020: | * @static |
| 12021: | */ |
| 12022: | public static function hasFile($key) |
| 12023: | { |
| 12024: | /** @var \Illuminate\Http\Request $instance */ |
| 12025: | return $instance->hasFile($key); |
| 12026: | } |
| 12027: | /** |
| 12028: | * Retrieve a file from the request. |
| 12029: | * |
| 12030: | * @param string|null $key |
| 12031: | * @param mixed $default |
| 12032: | * @return \Illuminate\Http\UploadedFile|\Illuminate\Http\UploadedFile[]|array|null |
| 12033: | * @static |
| 12034: | */ |
| 12035: | public static function file($key = null, $default = null) |
| 12036: | { |
| 12037: | /** @var \Illuminate\Http\Request $instance */ |
| 12038: | return $instance->file($key, $default); |
| 12039: | } |
| 12040: | /** |
| 12041: | * Dump the request items and end the script. |
| 12042: | * |
| 12043: | * @param mixed $keys |
| 12044: | * @return void |
| 12045: | * @static |
| 12046: | */ |
| 12047: | public static function dd(...$keys) |
| 12048: | { |
| 12049: | /** @var \Illuminate\Http\Request $instance */ |
| 12050: | $instance->dd(...$keys); |
| 12051: | } |
| 12052: | /** |
| 12053: | * Dump the items. |
| 12054: | * |
| 12055: | * @param mixed $keys |
| 12056: | * @return \Illuminate\Http\Request |
| 12057: | * @static |
| 12058: | */ |
| 12059: | public static function dump($keys = []) |
| 12060: | { |
| 12061: | /** @var \Illuminate\Http\Request $instance */ |
| 12062: | return $instance->dump($keys); |
| 12063: | } |
| 12064: | /** |
| 12065: | * Register a custom macro. |
| 12066: | * |
| 12067: | * @param string $name |
| 12068: | * @param object|callable $macro |
| 12069: | * @return void |
| 12070: | * @static |
| 12071: | */ |
| 12072: | public static function macro($name, $macro) |
| 12073: | { |
| 12074: | \Illuminate\Http\Request::macro($name, $macro); |
| 12075: | } |
| 12076: | /** |
| 12077: | * Mix another object into the class. |
| 12078: | * |
| 12079: | * @param object $mixin |
| 12080: | * @param bool $replace |
| 12081: | * @return void |
| 12082: | * @throws \ReflectionException |
| 12083: | * @static |
| 12084: | */ |
| 12085: | public static function mixin($mixin, $replace = true) |
| 12086: | { |
| 12087: | \Illuminate\Http\Request::mixin($mixin, $replace); |
| 12088: | } |
| 12089: | /** |
| 12090: | * Checks if macro is registered. |
| 12091: | * |
| 12092: | * @param string $name |
| 12093: | * @return bool |
| 12094: | * @static |
| 12095: | */ |
| 12096: | public static function hasMacro($name) |
| 12097: | { |
| 12098: | return \Illuminate\Http\Request::hasMacro($name); |
| 12099: | } |
| 12100: | /** |
| 12101: | * Flush the existing macros. |
| 12102: | * |
| 12103: | * @return void |
| 12104: | * @static |
| 12105: | */ |
| 12106: | public static function flushMacros() |
| 12107: | { |
| 12108: | \Illuminate\Http\Request::flushMacros(); |
| 12109: | } |
| 12110: | /** |
| 12111: | * |
| 12112: | * |
| 12113: | * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation() |
| 12114: | * @param array $rules |
| 12115: | * @param mixed $params |
| 12116: | * @static |
| 12117: | */ |
| 12118: | public static function validate($rules, ...$params) |
| 12119: | { |
| 12120: | return \Illuminate\Http\Request::validate($rules, ...$params); |
| 12121: | } |
| 12122: | /** |
| 12123: | * |
| 12124: | * |
| 12125: | * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation() |
| 12126: | * @param string $errorBag |
| 12127: | * @param array $rules |
| 12128: | * @param mixed $params |
| 12129: | * @static |
| 12130: | */ |
| 12131: | public static function validateWithBag($errorBag, $rules, ...$params) |
| 12132: | { |
| 12133: | return \Illuminate\Http\Request::validateWithBag($errorBag, $rules, ...$params); |
| 12134: | } |
| 12135: | /** |
| 12136: | * |
| 12137: | * |
| 12138: | * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation() |
| 12139: | * @param mixed $absolute |
| 12140: | * @static |
| 12141: | */ |
| 12142: | public static function hasValidSignature($absolute = true) |
| 12143: | { |
| 12144: | return \Illuminate\Http\Request::hasValidSignature($absolute); |
| 12145: | } |
| 12146: | /** |
| 12147: | * |
| 12148: | * |
| 12149: | * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation() |
| 12150: | * @static |
| 12151: | */ |
| 12152: | public static function hasValidRelativeSignature() |
| 12153: | { |
| 12154: | return \Illuminate\Http\Request::hasValidRelativeSignature(); |
| 12155: | } |
| 12156: | /** |
| 12157: | * |
| 12158: | * |
| 12159: | * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation() |
| 12160: | * @param mixed $ignoreQuery |
| 12161: | * @param mixed $absolute |
| 12162: | * @static |
| 12163: | */ |
| 12164: | public static function hasValidSignatureWhileIgnoring($ignoreQuery = [], $absolute = true) |
| 12165: | { |
| 12166: | return \Illuminate\Http\Request::hasValidSignatureWhileIgnoring($ignoreQuery, $absolute); |
| 12167: | } |
| 12168: | |
| 12169: | } |
| 12170: | /** |
| 12171: | * |
| 12172: | * |
| 12173: | * @see \Illuminate\Contracts\Routing\ResponseFactory |
| 12174: | */ |
| 12175: | class Response { |
| 12176: | /** |
| 12177: | * Create a new response instance. |
| 12178: | * |
| 12179: | * @param mixed $content |
| 12180: | * @param int $status |
| 12181: | * @param array $headers |
| 12182: | * @return \Illuminate\Http\Response |
| 12183: | * @static |
| 12184: | */ |
| 12185: | public static function make($content = '', $status = 200, $headers = []) |
| 12186: | { |
| 12187: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12188: | return $instance->make($content, $status, $headers); |
| 12189: | } |
| 12190: | /** |
| 12191: | * Create a new "no content" response. |
| 12192: | * |
| 12193: | * @param int $status |
| 12194: | * @param array $headers |
| 12195: | * @return \Illuminate\Http\Response |
| 12196: | * @static |
| 12197: | */ |
| 12198: | public static function noContent($status = 204, $headers = []) |
| 12199: | { |
| 12200: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12201: | return $instance->noContent($status, $headers); |
| 12202: | } |
| 12203: | /** |
| 12204: | * Create a new response for a given view. |
| 12205: | * |
| 12206: | * @param string|array $view |
| 12207: | * @param array $data |
| 12208: | * @param int $status |
| 12209: | * @param array $headers |
| 12210: | * @return \Illuminate\Http\Response |
| 12211: | * @static |
| 12212: | */ |
| 12213: | public static function view($view, $data = [], $status = 200, $headers = []) |
| 12214: | { |
| 12215: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12216: | return $instance->view($view, $data, $status, $headers); |
| 12217: | } |
| 12218: | /** |
| 12219: | * Create a new JSON response instance. |
| 12220: | * |
| 12221: | * @param mixed $data |
| 12222: | * @param int $status |
| 12223: | * @param array $headers |
| 12224: | * @param int $options |
| 12225: | * @return \Illuminate\Http\JsonResponse |
| 12226: | * @static |
| 12227: | */ |
| 12228: | public static function json($data = [], $status = 200, $headers = [], $options = 0) |
| 12229: | { |
| 12230: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12231: | return $instance->json($data, $status, $headers, $options); |
| 12232: | } |
| 12233: | /** |
| 12234: | * Create a new JSONP response instance. |
| 12235: | * |
| 12236: | * @param string $callback |
| 12237: | * @param mixed $data |
| 12238: | * @param int $status |
| 12239: | * @param array $headers |
| 12240: | * @param int $options |
| 12241: | * @return \Illuminate\Http\JsonResponse |
| 12242: | * @static |
| 12243: | */ |
| 12244: | public static function jsonp($callback, $data = [], $status = 200, $headers = [], $options = 0) |
| 12245: | { |
| 12246: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12247: | return $instance->jsonp($callback, $data, $status, $headers, $options); |
| 12248: | } |
| 12249: | /** |
| 12250: | * Create a new streamed response instance. |
| 12251: | * |
| 12252: | * @param \Closure $callback |
| 12253: | * @param int $status |
| 12254: | * @param array $headers |
| 12255: | * @return \Symfony\Component\HttpFoundation\StreamedResponse |
| 12256: | * @static |
| 12257: | */ |
| 12258: | public static function stream($callback, $status = 200, $headers = []) |
| 12259: | { |
| 12260: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12261: | return $instance->stream($callback, $status, $headers); |
| 12262: | } |
| 12263: | /** |
| 12264: | * Create a new streamed response instance as a file download. |
| 12265: | * |
| 12266: | * @param \Closure $callback |
| 12267: | * @param string|null $name |
| 12268: | * @param array $headers |
| 12269: | * @param string|null $disposition |
| 12270: | * @return \Symfony\Component\HttpFoundation\StreamedResponse |
| 12271: | * @static |
| 12272: | */ |
| 12273: | public static function streamDownload($callback, $name = null, $headers = [], $disposition = 'attachment') |
| 12274: | { |
| 12275: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12276: | return $instance->streamDownload($callback, $name, $headers, $disposition); |
| 12277: | } |
| 12278: | /** |
| 12279: | * Create a new file download response. |
| 12280: | * |
| 12281: | * @param \SplFileInfo|string $file |
| 12282: | * @param string|null $name |
| 12283: | * @param array $headers |
| 12284: | * @param string|null $disposition |
| 12285: | * @return \Symfony\Component\HttpFoundation\BinaryFileResponse |
| 12286: | * @static |
| 12287: | */ |
| 12288: | public static function download($file, $name = null, $headers = [], $disposition = 'attachment') |
| 12289: | { |
| 12290: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12291: | return $instance->download($file, $name, $headers, $disposition); |
| 12292: | } |
| 12293: | /** |
| 12294: | * Return the raw contents of a binary file. |
| 12295: | * |
| 12296: | * @param \SplFileInfo|string $file |
| 12297: | * @param array $headers |
| 12298: | * @return \Symfony\Component\HttpFoundation\BinaryFileResponse |
| 12299: | * @static |
| 12300: | */ |
| 12301: | public static function file($file, $headers = []) |
| 12302: | { |
| 12303: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12304: | return $instance->file($file, $headers); |
| 12305: | } |
| 12306: | /** |
| 12307: | * Create a new redirect response to the given path. |
| 12308: | * |
| 12309: | * @param string $path |
| 12310: | * @param int $status |
| 12311: | * @param array $headers |
| 12312: | * @param bool|null $secure |
| 12313: | * @return \Illuminate\Http\RedirectResponse |
| 12314: | * @static |
| 12315: | */ |
| 12316: | public static function redirectTo($path, $status = 302, $headers = [], $secure = null) |
| 12317: | { |
| 12318: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12319: | return $instance->redirectTo($path, $status, $headers, $secure); |
| 12320: | } |
| 12321: | /** |
| 12322: | * Create a new redirect response to a named route. |
| 12323: | * |
| 12324: | * @param string $route |
| 12325: | * @param mixed $parameters |
| 12326: | * @param int $status |
| 12327: | * @param array $headers |
| 12328: | * @return \Illuminate\Http\RedirectResponse |
| 12329: | * @static |
| 12330: | */ |
| 12331: | public static function redirectToRoute($route, $parameters = [], $status = 302, $headers = []) |
| 12332: | { |
| 12333: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12334: | return $instance->redirectToRoute($route, $parameters, $status, $headers); |
| 12335: | } |
| 12336: | /** |
| 12337: | * Create a new redirect response to a controller action. |
| 12338: | * |
| 12339: | * @param string $action |
| 12340: | * @param mixed $parameters |
| 12341: | * @param int $status |
| 12342: | * @param array $headers |
| 12343: | * @return \Illuminate\Http\RedirectResponse |
| 12344: | * @static |
| 12345: | */ |
| 12346: | public static function redirectToAction($action, $parameters = [], $status = 302, $headers = []) |
| 12347: | { |
| 12348: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12349: | return $instance->redirectToAction($action, $parameters, $status, $headers); |
| 12350: | } |
| 12351: | /** |
| 12352: | * Create a new redirect response, while putting the current URL in the session. |
| 12353: | * |
| 12354: | * @param string $path |
| 12355: | * @param int $status |
| 12356: | * @param array $headers |
| 12357: | * @param bool|null $secure |
| 12358: | * @return \Illuminate\Http\RedirectResponse |
| 12359: | * @static |
| 12360: | */ |
| 12361: | public static function redirectGuest($path, $status = 302, $headers = [], $secure = null) |
| 12362: | { |
| 12363: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12364: | return $instance->redirectGuest($path, $status, $headers, $secure); |
| 12365: | } |
| 12366: | /** |
| 12367: | * Create a new redirect response to the previously intended location. |
| 12368: | * |
| 12369: | * @param string $default |
| 12370: | * @param int $status |
| 12371: | * @param array $headers |
| 12372: | * @param bool|null $secure |
| 12373: | * @return \Illuminate\Http\RedirectResponse |
| 12374: | * @static |
| 12375: | */ |
| 12376: | public static function redirectToIntended($default = '/', $status = 302, $headers = [], $secure = null) |
| 12377: | { |
| 12378: | /** @var \Illuminate\Routing\ResponseFactory $instance */ |
| 12379: | return $instance->redirectToIntended($default, $status, $headers, $secure); |
| 12380: | } |
| 12381: | /** |
| 12382: | * Register a custom macro. |
| 12383: | * |
| 12384: | * @param string $name |
| 12385: | * @param object|callable $macro |
| 12386: | * @return void |
| 12387: | * @static |
| 12388: | */ |
| 12389: | public static function macro($name, $macro) |
| 12390: | { |
| 12391: | \Illuminate\Routing\ResponseFactory::macro($name, $macro); |
| 12392: | } |
| 12393: | /** |
| 12394: | * Mix another object into the class. |
| 12395: | * |
| 12396: | * @param object $mixin |
| 12397: | * @param bool $replace |
| 12398: | * @return void |
| 12399: | * @throws \ReflectionException |
| 12400: | * @static |
| 12401: | */ |
| 12402: | public static function mixin($mixin, $replace = true) |
| 12403: | { |
| 12404: | \Illuminate\Routing\ResponseFactory::mixin($mixin, $replace); |
| 12405: | } |
| 12406: | /** |
| 12407: | * Checks if macro is registered. |
| 12408: | * |
| 12409: | * @param string $name |
| 12410: | * @return bool |
| 12411: | * @static |
| 12412: | */ |
| 12413: | public static function hasMacro($name) |
| 12414: | { |
| 12415: | return \Illuminate\Routing\ResponseFactory::hasMacro($name); |
| 12416: | } |
| 12417: | /** |
| 12418: | * Flush the existing macros. |
| 12419: | * |
| 12420: | * @return void |
| 12421: | * @static |
| 12422: | */ |
| 12423: | public static function flushMacros() |
| 12424: | { |
| 12425: | \Illuminate\Routing\ResponseFactory::flushMacros(); |
| 12426: | } |
| 12427: | |
| 12428: | } |
| 12429: | /** |
| 12430: | * |
| 12431: | * |
| 12432: | * @method static \Illuminate\Routing\RouteRegistrar as(string $value) |
| 12433: | * @method static \Illuminate\Routing\RouteRegistrar controller(string $controller) |
| 12434: | * @method static \Illuminate\Routing\RouteRegistrar domain(string $value) |
| 12435: | * @method static \Illuminate\Routing\RouteRegistrar middleware(array|string|null $middleware) |
| 12436: | * @method static \Illuminate\Routing\RouteRegistrar name(string $value) |
| 12437: | * @method static \Illuminate\Routing\RouteRegistrar namespace(string|null $value) |
| 12438: | * @method static \Illuminate\Routing\RouteRegistrar prefix(string $prefix) |
| 12439: | * @method static \Illuminate\Routing\RouteRegistrar scopeBindings() |
| 12440: | * @method static \Illuminate\Routing\RouteRegistrar where(array $where) |
| 12441: | * @method static \Illuminate\Routing\RouteRegistrar withoutMiddleware(array|string $middleware) |
| 12442: | * @see \Illuminate\Routing\Router |
| 12443: | */ |
| 12444: | class Route { |
| 12445: | /** |
| 12446: | * Register a new GET route with the router. |
| 12447: | * |
| 12448: | * @param string $uri |
| 12449: | * @param array|string|callable|null $action |
| 12450: | * @return \Illuminate\Routing\Route |
| 12451: | * @static |
| 12452: | */ |
| 12453: | public static function get($uri, $action = null) |
| 12454: | { |
| 12455: | /** @var \Illuminate\Routing\Router $instance */ |
| 12456: | return $instance->get($uri, $action); |
| 12457: | } |
| 12458: | /** |
| 12459: | * Register a new POST route with the router. |
| 12460: | * |
| 12461: | * @param string $uri |
| 12462: | * @param array|string|callable|null $action |
| 12463: | * @return \Illuminate\Routing\Route |
| 12464: | * @static |
| 12465: | */ |
| 12466: | public static function post($uri, $action = null) |
| 12467: | { |
| 12468: | /** @var \Illuminate\Routing\Router $instance */ |
| 12469: | return $instance->post($uri, $action); |
| 12470: | } |
| 12471: | /** |
| 12472: | * Register a new PUT route with the router. |
| 12473: | * |
| 12474: | * @param string $uri |
| 12475: | * @param array|string|callable|null $action |
| 12476: | * @return \Illuminate\Routing\Route |
| 12477: | * @static |
| 12478: | */ |
| 12479: | public static function put($uri, $action = null) |
| 12480: | { |
| 12481: | /** @var \Illuminate\Routing\Router $instance */ |
| 12482: | return $instance->put($uri, $action); |
| 12483: | } |
| 12484: | /** |
| 12485: | * Register a new PATCH route with the router. |
| 12486: | * |
| 12487: | * @param string $uri |
| 12488: | * @param array|string|callable|null $action |
| 12489: | * @return \Illuminate\Routing\Route |
| 12490: | * @static |
| 12491: | */ |
| 12492: | public static function patch($uri, $action = null) |
| 12493: | { |
| 12494: | /** @var \Illuminate\Routing\Router $instance */ |
| 12495: | return $instance->patch($uri, $action); |
| 12496: | } |
| 12497: | /** |
| 12498: | * Register a new DELETE route with the router. |
| 12499: | * |
| 12500: | * @param string $uri |
| 12501: | * @param array|string|callable|null $action |
| 12502: | * @return \Illuminate\Routing\Route |
| 12503: | * @static |
| 12504: | */ |
| 12505: | public static function delete($uri, $action = null) |
| 12506: | { |
| 12507: | /** @var \Illuminate\Routing\Router $instance */ |
| 12508: | return $instance->delete($uri, $action); |
| 12509: | } |
| 12510: | /** |
| 12511: | * Register a new OPTIONS route with the router. |
| 12512: | * |
| 12513: | * @param string $uri |
| 12514: | * @param array|string|callable|null $action |
| 12515: | * @return \Illuminate\Routing\Route |
| 12516: | * @static |
| 12517: | */ |
| 12518: | public static function options($uri, $action = null) |
| 12519: | { |
| 12520: | /** @var \Illuminate\Routing\Router $instance */ |
| 12521: | return $instance->options($uri, $action); |
| 12522: | } |
| 12523: | /** |
| 12524: | * Register a new route responding to all verbs. |
| 12525: | * |
| 12526: | * @param string $uri |
| 12527: | * @param array|string|callable|null $action |
| 12528: | * @return \Illuminate\Routing\Route |
| 12529: | * @static |
| 12530: | */ |
| 12531: | public static function any($uri, $action = null) |
| 12532: | { |
| 12533: | /** @var \Illuminate\Routing\Router $instance */ |
| 12534: | return $instance->any($uri, $action); |
| 12535: | } |
| 12536: | /** |
| 12537: | * Register a new Fallback route with the router. |
| 12538: | * |
| 12539: | * @param array|string|callable|null $action |
| 12540: | * @return \Illuminate\Routing\Route |
| 12541: | * @static |
| 12542: | */ |
| 12543: | public static function fallback($action) |
| 12544: | { |
| 12545: | /** @var \Illuminate\Routing\Router $instance */ |
| 12546: | return $instance->fallback($action); |
| 12547: | } |
| 12548: | /** |
| 12549: | * Create a redirect from one URI to another. |
| 12550: | * |
| 12551: | * @param string $uri |
| 12552: | * @param string $destination |
| 12553: | * @param int $status |
| 12554: | * @return \Illuminate\Routing\Route |
| 12555: | * @static |
| 12556: | */ |
| 12557: | public static function redirect($uri, $destination, $status = 302) |
| 12558: | { |
| 12559: | /** @var \Illuminate\Routing\Router $instance */ |
| 12560: | return $instance->redirect($uri, $destination, $status); |
| 12561: | } |
| 12562: | /** |
| 12563: | * Create a permanent redirect from one URI to another. |
| 12564: | * |
| 12565: | * @param string $uri |
| 12566: | * @param string $destination |
| 12567: | * @return \Illuminate\Routing\Route |
| 12568: | * @static |
| 12569: | */ |
| 12570: | public static function permanentRedirect($uri, $destination) |
| 12571: | { |
| 12572: | /** @var \Illuminate\Routing\Router $instance */ |
| 12573: | return $instance->permanentRedirect($uri, $destination); |
| 12574: | } |
| 12575: | /** |
| 12576: | * Register a new route that returns a view. |
| 12577: | * |
| 12578: | * @param string $uri |
| 12579: | * @param string $view |
| 12580: | * @param array $data |
| 12581: | * @param int|array $status |
| 12582: | * @param array $headers |
| 12583: | * @return \Illuminate\Routing\Route |
| 12584: | * @static |
| 12585: | */ |
| 12586: | public static function view($uri, $view, $data = [], $status = 200, $headers = []) |
| 12587: | { |
| 12588: | /** @var \Illuminate\Routing\Router $instance */ |
| 12589: | return $instance->view($uri, $view, $data, $status, $headers); |
| 12590: | } |
| 12591: | /** |
| 12592: | * Register a new route with the given verbs. |
| 12593: | * |
| 12594: | * @param array|string $methods |
| 12595: | * @param string $uri |
| 12596: | * @param array|string|callable|null $action |
| 12597: | * @return \Illuminate\Routing\Route |
| 12598: | * @static |
| 12599: | */ |
| 12600: | public static function match($methods, $uri, $action = null) |
| 12601: | { |
| 12602: | /** @var \Illuminate\Routing\Router $instance */ |
| 12603: | return $instance->match($methods, $uri, $action); |
| 12604: | } |
| 12605: | /** |
| 12606: | * Register an array of resource controllers. |
| 12607: | * |
| 12608: | * @param array $resources |
| 12609: | * @param array $options |
| 12610: | * @return void |
| 12611: | * @static |
| 12612: | */ |
| 12613: | public static function resources($resources, $options = []) |
| 12614: | { |
| 12615: | /** @var \Illuminate\Routing\Router $instance */ |
| 12616: | $instance->resources($resources, $options); |
| 12617: | } |
| 12618: | /** |
| 12619: | * Route a resource to a controller. |
| 12620: | * |
| 12621: | * @param string $name |
| 12622: | * @param string $controller |
| 12623: | * @param array $options |
| 12624: | * @return \Illuminate\Routing\PendingResourceRegistration |
| 12625: | * @static |
| 12626: | */ |
| 12627: | public static function resource($name, $controller, $options = []) |
| 12628: | { |
| 12629: | /** @var \Illuminate\Routing\Router $instance */ |
| 12630: | return $instance->resource($name, $controller, $options); |
| 12631: | } |
| 12632: | /** |
| 12633: | * Register an array of API resource controllers. |
| 12634: | * |
| 12635: | * @param array $resources |
| 12636: | * @param array $options |
| 12637: | * @return void |
| 12638: | * @static |
| 12639: | */ |
| 12640: | public static function apiResources($resources, $options = []) |
| 12641: | { |
| 12642: | /** @var \Illuminate\Routing\Router $instance */ |
| 12643: | $instance->apiResources($resources, $options); |
| 12644: | } |
| 12645: | /** |
| 12646: | * Route an API resource to a controller. |
| 12647: | * |
| 12648: | * @param string $name |
| 12649: | * @param string $controller |
| 12650: | * @param array $options |
| 12651: | * @return \Illuminate\Routing\PendingResourceRegistration |
| 12652: | * @static |
| 12653: | */ |
| 12654: | public static function apiResource($name, $controller, $options = []) |
| 12655: | { |
| 12656: | /** @var \Illuminate\Routing\Router $instance */ |
| 12657: | return $instance->apiResource($name, $controller, $options); |
| 12658: | } |
| 12659: | /** |
| 12660: | * Create a route group with shared attributes. |
| 12661: | * |
| 12662: | * @param array $attributes |
| 12663: | * @param \Closure|array|string $routes |
| 12664: | * @return void |
| 12665: | * @static |
| 12666: | */ |
| 12667: | public static function group($attributes, $routes) |
| 12668: | { |
| 12669: | /** @var \Illuminate\Routing\Router $instance */ |
| 12670: | $instance->group($attributes, $routes); |
| 12671: | } |
| 12672: | /** |
| 12673: | * Merge the given array with the last group stack. |
| 12674: | * |
| 12675: | * @param array $new |
| 12676: | * @param bool $prependExistingPrefix |
| 12677: | * @return array |
| 12678: | * @static |
| 12679: | */ |
| 12680: | public static function mergeWithLastGroup($new, $prependExistingPrefix = true) |
| 12681: | { |
| 12682: | /** @var \Illuminate\Routing\Router $instance */ |
| 12683: | return $instance->mergeWithLastGroup($new, $prependExistingPrefix); |
| 12684: | } |
| 12685: | /** |
| 12686: | * Get the prefix from the last group on the stack. |
| 12687: | * |
| 12688: | * @return string |
| 12689: | * @static |
| 12690: | */ |
| 12691: | public static function getLastGroupPrefix() |
| 12692: | { |
| 12693: | /** @var \Illuminate\Routing\Router $instance */ |
| 12694: | return $instance->getLastGroupPrefix(); |
| 12695: | } |
| 12696: | /** |
| 12697: | * Add a route to the underlying route collection. |
| 12698: | * |
| 12699: | * @param array|string $methods |
| 12700: | * @param string $uri |
| 12701: | * @param array|string|callable|null $action |
| 12702: | * @return \Illuminate\Routing\Route |
| 12703: | * @static |
| 12704: | */ |
| 12705: | public static function addRoute($methods, $uri, $action) |
| 12706: | { |
| 12707: | /** @var \Illuminate\Routing\Router $instance */ |
| 12708: | return $instance->addRoute($methods, $uri, $action); |
| 12709: | } |
| 12710: | /** |
| 12711: | * Create a new Route object. |
| 12712: | * |
| 12713: | * @param array|string $methods |
| 12714: | * @param string $uri |
| 12715: | * @param mixed $action |
| 12716: | * @return \Illuminate\Routing\Route |
| 12717: | * @static |
| 12718: | */ |
| 12719: | public static function newRoute($methods, $uri, $action) |
| 12720: | { |
| 12721: | /** @var \Illuminate\Routing\Router $instance */ |
| 12722: | return $instance->newRoute($methods, $uri, $action); |
| 12723: | } |
| 12724: | /** |
| 12725: | * Return the response returned by the given route. |
| 12726: | * |
| 12727: | * @param string $name |
| 12728: | * @return \Symfony\Component\HttpFoundation\Response |
| 12729: | * @static |
| 12730: | */ |
| 12731: | public static function respondWithRoute($name) |
| 12732: | { |
| 12733: | /** @var \Illuminate\Routing\Router $instance */ |
| 12734: | return $instance->respondWithRoute($name); |
| 12735: | } |
| 12736: | /** |
| 12737: | * Dispatch the request to the application. |
| 12738: | * |
| 12739: | * @param \Illuminate\Http\Request $request |
| 12740: | * @return \Symfony\Component\HttpFoundation\Response |
| 12741: | * @static |
| 12742: | */ |
| 12743: | public static function dispatch($request) |
| 12744: | { |
| 12745: | /** @var \Illuminate\Routing\Router $instance */ |
| 12746: | return $instance->dispatch($request); |
| 12747: | } |
| 12748: | /** |
| 12749: | * Dispatch the request to a route and return the response. |
| 12750: | * |
| 12751: | * @param \Illuminate\Http\Request $request |
| 12752: | * @return \Symfony\Component\HttpFoundation\Response |
| 12753: | * @static |
| 12754: | */ |
| 12755: | public static function dispatchToRoute($request) |
| 12756: | { |
| 12757: | /** @var \Illuminate\Routing\Router $instance */ |
| 12758: | return $instance->dispatchToRoute($request); |
| 12759: | } |
| 12760: | /** |
| 12761: | * Gather the middleware for the given route with resolved class names. |
| 12762: | * |
| 12763: | * @param \Illuminate\Routing\Route $route |
| 12764: | * @return array |
| 12765: | * @static |
| 12766: | */ |
| 12767: | public static function gatherRouteMiddleware($route) |
| 12768: | { |
| 12769: | /** @var \Illuminate\Routing\Router $instance */ |
| 12770: | return $instance->gatherRouteMiddleware($route); |
| 12771: | } |
| 12772: | /** |
| 12773: | * Resolve a flat array of middleware classes from the provided array. |
| 12774: | * |
| 12775: | * @param array $middleware |
| 12776: | * @param array $excluded |
| 12777: | * @return array |
| 12778: | * @static |
| 12779: | */ |
| 12780: | public static function resolveMiddleware($middleware, $excluded = []) |
| 12781: | { |
| 12782: | /** @var \Illuminate\Routing\Router $instance */ |
| 12783: | return $instance->resolveMiddleware($middleware, $excluded); |
| 12784: | } |
| 12785: | /** |
| 12786: | * Create a response instance from the given value. |
| 12787: | * |
| 12788: | * @param \Symfony\Component\HttpFoundation\Request $request |
| 12789: | * @param mixed $response |
| 12790: | * @return \Symfony\Component\HttpFoundation\Response |
| 12791: | * @static |
| 12792: | */ |
| 12793: | public static function prepareResponse($request, $response) |
| 12794: | { |
| 12795: | /** @var \Illuminate\Routing\Router $instance */ |
| 12796: | return $instance->prepareResponse($request, $response); |
| 12797: | } |
| 12798: | /** |
| 12799: | * Static version of prepareResponse. |
| 12800: | * |
| 12801: | * @param \Symfony\Component\HttpFoundation\Request $request |
| 12802: | * @param mixed $response |
| 12803: | * @return \Symfony\Component\HttpFoundation\Response |
| 12804: | * @static |
| 12805: | */ |
| 12806: | public static function toResponse($request, $response) |
| 12807: | { |
| 12808: | return \Illuminate\Routing\Router::toResponse($request, $response); |
| 12809: | } |
| 12810: | /** |
| 12811: | * Substitute the route bindings onto the route. |
| 12812: | * |
| 12813: | * @param \Illuminate\Routing\Route $route |
| 12814: | * @return \Illuminate\Routing\Route |
| 12815: | * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model> |
| 12816: | * @throws \Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException |
| 12817: | * @static |
| 12818: | */ |
| 12819: | public static function substituteBindings($route) |
| 12820: | { |
| 12821: | /** @var \Illuminate\Routing\Router $instance */ |
| 12822: | return $instance->substituteBindings($route); |
| 12823: | } |
| 12824: | /** |
| 12825: | * Substitute the implicit route bindings for the given route. |
| 12826: | * |
| 12827: | * @param \Illuminate\Routing\Route $route |
| 12828: | * @return void |
| 12829: | * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model> |
| 12830: | * @throws \Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException |
| 12831: | * @static |
| 12832: | */ |
| 12833: | public static function substituteImplicitBindings($route) |
| 12834: | { |
| 12835: | /** @var \Illuminate\Routing\Router $instance */ |
| 12836: | $instance->substituteImplicitBindings($route); |
| 12837: | } |
| 12838: | /** |
| 12839: | * Register a route matched event listener. |
| 12840: | * |
| 12841: | * @param string|callable $callback |
| 12842: | * @return void |
| 12843: | * @static |
| 12844: | */ |
| 12845: | public static function matched($callback) |
| 12846: | { |
| 12847: | /** @var \Illuminate\Routing\Router $instance */ |
| 12848: | $instance->matched($callback); |
| 12849: | } |
| 12850: | /** |
| 12851: | * Get all of the defined middleware short-hand names. |
| 12852: | * |
| 12853: | * @return array |
| 12854: | * @static |
| 12855: | */ |
| 12856: | public static function getMiddleware() |
| 12857: | { |
| 12858: | /** @var \Illuminate\Routing\Router $instance */ |
| 12859: | return $instance->getMiddleware(); |
| 12860: | } |
| 12861: | /** |
| 12862: | * Register a short-hand name for a middleware. |
| 12863: | * |
| 12864: | * @param string $name |
| 12865: | * @param string $class |
| 12866: | * @return \Illuminate\Routing\Router |
| 12867: | * @static |
| 12868: | */ |
| 12869: | public static function aliasMiddleware($name, $class) |
| 12870: | { |
| 12871: | /** @var \Illuminate\Routing\Router $instance */ |
| 12872: | return $instance->aliasMiddleware($name, $class); |
| 12873: | } |
| 12874: | /** |
| 12875: | * Check if a middlewareGroup with the given name exists. |
| 12876: | * |
| 12877: | * @param string $name |
| 12878: | * @return bool |
| 12879: | * @static |
| 12880: | */ |
| 12881: | public static function hasMiddlewareGroup($name) |
| 12882: | { |
| 12883: | /** @var \Illuminate\Routing\Router $instance */ |
| 12884: | return $instance->hasMiddlewareGroup($name); |
| 12885: | } |
| 12886: | /** |
| 12887: | * Get all of the defined middleware groups. |
| 12888: | * |
| 12889: | * @return array |
| 12890: | * @static |
| 12891: | */ |
| 12892: | public static function getMiddlewareGroups() |
| 12893: | { |
| 12894: | /** @var \Illuminate\Routing\Router $instance */ |
| 12895: | return $instance->getMiddlewareGroups(); |
| 12896: | } |
| 12897: | /** |
| 12898: | * Register a group of middleware. |
| 12899: | * |
| 12900: | * @param string $name |
| 12901: | * @param array $middleware |
| 12902: | * @return \Illuminate\Routing\Router |
| 12903: | * @static |
| 12904: | */ |
| 12905: | public static function middlewareGroup($name, $middleware) |
| 12906: | { |
| 12907: | /** @var \Illuminate\Routing\Router $instance */ |
| 12908: | return $instance->middlewareGroup($name, $middleware); |
| 12909: | } |
| 12910: | /** |
| 12911: | * Add a middleware to the beginning of a middleware group. |
| 12912: | * |
| 12913: | * If the middleware is already in the group, it will not be added again. |
| 12914: | * |
| 12915: | * @param string $group |
| 12916: | * @param string $middleware |
| 12917: | * @return \Illuminate\Routing\Router |
| 12918: | * @static |
| 12919: | */ |
| 12920: | public static function prependMiddlewareToGroup($group, $middleware) |
| 12921: | { |
| 12922: | /** @var \Illuminate\Routing\Router $instance */ |
| 12923: | return $instance->prependMiddlewareToGroup($group, $middleware); |
| 12924: | } |
| 12925: | /** |
| 12926: | * Add a middleware to the end of a middleware group. |
| 12927: | * |
| 12928: | * If the middleware is already in the group, it will not be added again. |
| 12929: | * |
| 12930: | * @param string $group |
| 12931: | * @param string $middleware |
| 12932: | * @return \Illuminate\Routing\Router |
| 12933: | * @static |
| 12934: | */ |
| 12935: | public static function pushMiddlewareToGroup($group, $middleware) |
| 12936: | { |
| 12937: | /** @var \Illuminate\Routing\Router $instance */ |
| 12938: | return $instance->pushMiddlewareToGroup($group, $middleware); |
| 12939: | } |
| 12940: | /** |
| 12941: | * Flush the router's middleware groups. |
| 12942: | * |
| 12943: | * @return \Illuminate\Routing\Router |
| 12944: | * @static |
| 12945: | */ |
| 12946: | public static function flushMiddlewareGroups() |
| 12947: | { |
| 12948: | /** @var \Illuminate\Routing\Router $instance */ |
| 12949: | return $instance->flushMiddlewareGroups(); |
| 12950: | } |
| 12951: | /** |
| 12952: | * Add a new route parameter binder. |
| 12953: | * |
| 12954: | * @param string $key |
| 12955: | * @param string|callable $binder |
| 12956: | * @return void |
| 12957: | * @static |
| 12958: | */ |
| 12959: | public static function bind($key, $binder) |
| 12960: | { |
| 12961: | /** @var \Illuminate\Routing\Router $instance */ |
| 12962: | $instance->bind($key, $binder); |
| 12963: | } |
| 12964: | /** |
| 12965: | * Register a model binder for a wildcard. |
| 12966: | * |
| 12967: | * @param string $key |
| 12968: | * @param string $class |
| 12969: | * @param \Closure|null $callback |
| 12970: | * @return void |
| 12971: | * @static |
| 12972: | */ |
| 12973: | public static function model($key, $class, $callback = null) |
| 12974: | { |
| 12975: | /** @var \Illuminate\Routing\Router $instance */ |
| 12976: | $instance->model($key, $class, $callback); |
| 12977: | } |
| 12978: | /** |
| 12979: | * Get the binding callback for a given binding. |
| 12980: | * |
| 12981: | * @param string $key |
| 12982: | * @return \Closure|null |
| 12983: | * @static |
| 12984: | */ |
| 12985: | public static function getBindingCallback($key) |
| 12986: | { |
| 12987: | /** @var \Illuminate\Routing\Router $instance */ |
| 12988: | return $instance->getBindingCallback($key); |
| 12989: | } |
| 12990: | /** |
| 12991: | * Get the global "where" patterns. |
| 12992: | * |
| 12993: | * @return array |
| 12994: | * @static |
| 12995: | */ |
| 12996: | public static function getPatterns() |
| 12997: | { |
| 12998: | /** @var \Illuminate\Routing\Router $instance */ |
| 12999: | return $instance->getPatterns(); |
| 13000: | } |
| 13001: | /** |
| 13002: | * Set a global where pattern on all routes. |
| 13003: | * |
| 13004: | * @param string $key |
| 13005: | * @param string $pattern |
| 13006: | * @return void |
| 13007: | * @static |
| 13008: | */ |
| 13009: | public static function pattern($key, $pattern) |
| 13010: | { |
| 13011: | /** @var \Illuminate\Routing\Router $instance */ |
| 13012: | $instance->pattern($key, $pattern); |
| 13013: | } |
| 13014: | /** |
| 13015: | * Set a group of global where patterns on all routes. |
| 13016: | * |
| 13017: | * @param array $patterns |
| 13018: | * @return void |
| 13019: | * @static |
| 13020: | */ |
| 13021: | public static function patterns($patterns) |
| 13022: | { |
| 13023: | /** @var \Illuminate\Routing\Router $instance */ |
| 13024: | $instance->patterns($patterns); |
| 13025: | } |
| 13026: | /** |
| 13027: | * Determine if the router currently has a group stack. |
| 13028: | * |
| 13029: | * @return bool |
| 13030: | * @static |
| 13031: | */ |
| 13032: | public static function hasGroupStack() |
| 13033: | { |
| 13034: | /** @var \Illuminate\Routing\Router $instance */ |
| 13035: | return $instance->hasGroupStack(); |
| 13036: | } |
| 13037: | /** |
| 13038: | * Get the current group stack for the router. |
| 13039: | * |
| 13040: | * @return array |
| 13041: | * @static |
| 13042: | */ |
| 13043: | public static function getGroupStack() |
| 13044: | { |
| 13045: | /** @var \Illuminate\Routing\Router $instance */ |
| 13046: | return $instance->getGroupStack(); |
| 13047: | } |
| 13048: | /** |
| 13049: | * Get a route parameter for the current route. |
| 13050: | * |
| 13051: | * @param string $key |
| 13052: | * @param string|null $default |
| 13053: | * @return mixed |
| 13054: | * @static |
| 13055: | */ |
| 13056: | public static function input($key, $default = null) |
| 13057: | { |
| 13058: | /** @var \Illuminate\Routing\Router $instance */ |
| 13059: | return $instance->input($key, $default); |
| 13060: | } |
| 13061: | /** |
| 13062: | * Get the request currently being dispatched. |
| 13063: | * |
| 13064: | * @return \Illuminate\Http\Request |
| 13065: | * @static |
| 13066: | */ |
| 13067: | public static function getCurrentRequest() |
| 13068: | { |
| 13069: | /** @var \Illuminate\Routing\Router $instance */ |
| 13070: | return $instance->getCurrentRequest(); |
| 13071: | } |
| 13072: | /** |
| 13073: | * Get the currently dispatched route instance. |
| 13074: | * |
| 13075: | * @return \Illuminate\Routing\Route|null |
| 13076: | * @static |
| 13077: | */ |
| 13078: | public static function getCurrentRoute() |
| 13079: | { |
| 13080: | /** @var \Illuminate\Routing\Router $instance */ |
| 13081: | return $instance->getCurrentRoute(); |
| 13082: | } |
| 13083: | /** |
| 13084: | * Get the currently dispatched route instance. |
| 13085: | * |
| 13086: | * @return \Illuminate\Routing\Route|null |
| 13087: | * @static |
| 13088: | */ |
| 13089: | public static function current() |
| 13090: | { |
| 13091: | /** @var \Illuminate\Routing\Router $instance */ |
| 13092: | return $instance->current(); |
| 13093: | } |
| 13094: | /** |
| 13095: | * Check if a route with the given name exists. |
| 13096: | * |
| 13097: | * @param string|array $name |
| 13098: | * @return bool |
| 13099: | * @static |
| 13100: | */ |
| 13101: | public static function has($name) |
| 13102: | { |
| 13103: | /** @var \Illuminate\Routing\Router $instance */ |
| 13104: | return $instance->has($name); |
| 13105: | } |
| 13106: | /** |
| 13107: | * Get the current route name. |
| 13108: | * |
| 13109: | * @return string|null |
| 13110: | * @static |
| 13111: | */ |
| 13112: | public static function currentRouteName() |
| 13113: | { |
| 13114: | /** @var \Illuminate\Routing\Router $instance */ |
| 13115: | return $instance->currentRouteName(); |
| 13116: | } |
| 13117: | /** |
| 13118: | * Alias for the "currentRouteNamed" method. |
| 13119: | * |
| 13120: | * @param mixed $patterns |
| 13121: | * @return bool |
| 13122: | * @static |
| 13123: | */ |
| 13124: | public static function is(...$patterns) |
| 13125: | { |
| 13126: | /** @var \Illuminate\Routing\Router $instance */ |
| 13127: | return $instance->is(...$patterns); |
| 13128: | } |
| 13129: | /** |
| 13130: | * Determine if the current route matches a pattern. |
| 13131: | * |
| 13132: | * @param mixed $patterns |
| 13133: | * @return bool |
| 13134: | * @static |
| 13135: | */ |
| 13136: | public static function currentRouteNamed(...$patterns) |
| 13137: | { |
| 13138: | /** @var \Illuminate\Routing\Router $instance */ |
| 13139: | return $instance->currentRouteNamed(...$patterns); |
| 13140: | } |
| 13141: | /** |
| 13142: | * Get the current route action. |
| 13143: | * |
| 13144: | * @return string|null |
| 13145: | * @static |
| 13146: | */ |
| 13147: | public static function currentRouteAction() |
| 13148: | { |
| 13149: | /** @var \Illuminate\Routing\Router $instance */ |
| 13150: | return $instance->currentRouteAction(); |
| 13151: | } |
| 13152: | /** |
| 13153: | * Alias for the "currentRouteUses" method. |
| 13154: | * |
| 13155: | * @param array $patterns |
| 13156: | * @return bool |
| 13157: | * @static |
| 13158: | */ |
| 13159: | public static function uses(...$patterns) |
| 13160: | { |
| 13161: | /** @var \Illuminate\Routing\Router $instance */ |
| 13162: | return $instance->uses(...$patterns); |
| 13163: | } |
| 13164: | /** |
| 13165: | * Determine if the current route action matches a given action. |
| 13166: | * |
| 13167: | * @param string $action |
| 13168: | * @return bool |
| 13169: | * @static |
| 13170: | */ |
| 13171: | public static function currentRouteUses($action) |
| 13172: | { |
| 13173: | /** @var \Illuminate\Routing\Router $instance */ |
| 13174: | return $instance->currentRouteUses($action); |
| 13175: | } |
| 13176: | /** |
| 13177: | * Set the unmapped global resource parameters to singular. |
| 13178: | * |
| 13179: | * @param bool $singular |
| 13180: | * @return void |
| 13181: | * @static |
| 13182: | */ |
| 13183: | public static function singularResourceParameters($singular = true) |
| 13184: | { |
| 13185: | /** @var \Illuminate\Routing\Router $instance */ |
| 13186: | $instance->singularResourceParameters($singular); |
| 13187: | } |
| 13188: | /** |
| 13189: | * Set the global resource parameter mapping. |
| 13190: | * |
| 13191: | * @param array $parameters |
| 13192: | * @return void |
| 13193: | * @static |
| 13194: | */ |
| 13195: | public static function resourceParameters($parameters = []) |
| 13196: | { |
| 13197: | /** @var \Illuminate\Routing\Router $instance */ |
| 13198: | $instance->resourceParameters($parameters); |
| 13199: | } |
| 13200: | /** |
| 13201: | * Get or set the verbs used in the resource URIs. |
| 13202: | * |
| 13203: | * @param array $verbs |
| 13204: | * @return array|null |
| 13205: | * @static |
| 13206: | */ |
| 13207: | public static function resourceVerbs($verbs = []) |
| 13208: | { |
| 13209: | /** @var \Illuminate\Routing\Router $instance */ |
| 13210: | return $instance->resourceVerbs($verbs); |
| 13211: | } |
| 13212: | /** |
| 13213: | * Get the underlying route collection. |
| 13214: | * |
| 13215: | * @return \Illuminate\Routing\RouteCollectionInterface |
| 13216: | * @static |
| 13217: | */ |
| 13218: | public static function getRoutes() |
| 13219: | { |
| 13220: | /** @var \Illuminate\Routing\Router $instance */ |
| 13221: | return $instance->getRoutes(); |
| 13222: | } |
| 13223: | /** |
| 13224: | * Set the route collection instance. |
| 13225: | * |
| 13226: | * @param \Illuminate\Routing\RouteCollection $routes |
| 13227: | * @return void |
| 13228: | * @static |
| 13229: | */ |
| 13230: | public static function setRoutes($routes) |
| 13231: | { |
| 13232: | /** @var \Illuminate\Routing\Router $instance */ |
| 13233: | $instance->setRoutes($routes); |
| 13234: | } |
| 13235: | /** |
| 13236: | * Set the compiled route collection instance. |
| 13237: | * |
| 13238: | * @param array $routes |
| 13239: | * @return void |
| 13240: | * @static |
| 13241: | */ |
| 13242: | public static function setCompiledRoutes($routes) |
| 13243: | { |
| 13244: | /** @var \Illuminate\Routing\Router $instance */ |
| 13245: | $instance->setCompiledRoutes($routes); |
| 13246: | } |
| 13247: | /** |
| 13248: | * Remove any duplicate middleware from the given array. |
| 13249: | * |
| 13250: | * @param array $middleware |
| 13251: | * @return array |
| 13252: | * @static |
| 13253: | */ |
| 13254: | public static function uniqueMiddleware($middleware) |
| 13255: | { |
| 13256: | return \Illuminate\Routing\Router::uniqueMiddleware($middleware); |
| 13257: | } |
| 13258: | /** |
| 13259: | * Set the container instance used by the router. |
| 13260: | * |
| 13261: | * @param \Illuminate\Container\Container $container |
| 13262: | * @return \Illuminate\Routing\Router |
| 13263: | * @static |
| 13264: | */ |
| 13265: | public static function setContainer($container) |
| 13266: | { |
| 13267: | /** @var \Illuminate\Routing\Router $instance */ |
| 13268: | return $instance->setContainer($container); |
| 13269: | } |
| 13270: | /** |
| 13271: | * Register a custom macro. |
| 13272: | * |
| 13273: | * @param string $name |
| 13274: | * @param object|callable $macro |
| 13275: | * @return void |
| 13276: | * @static |
| 13277: | */ |
| 13278: | public static function macro($name, $macro) |
| 13279: | { |
| 13280: | \Illuminate\Routing\Router::macro($name, $macro); |
| 13281: | } |
| 13282: | /** |
| 13283: | * Mix another object into the class. |
| 13284: | * |
| 13285: | * @param object $mixin |
| 13286: | * @param bool $replace |
| 13287: | * @return void |
| 13288: | * @throws \ReflectionException |
| 13289: | * @static |
| 13290: | */ |
| 13291: | public static function mixin($mixin, $replace = true) |
| 13292: | { |
| 13293: | \Illuminate\Routing\Router::mixin($mixin, $replace); |
| 13294: | } |
| 13295: | /** |
| 13296: | * Checks if macro is registered. |
| 13297: | * |
| 13298: | * @param string $name |
| 13299: | * @return bool |
| 13300: | * @static |
| 13301: | */ |
| 13302: | public static function hasMacro($name) |
| 13303: | { |
| 13304: | return \Illuminate\Routing\Router::hasMacro($name); |
| 13305: | } |
| 13306: | /** |
| 13307: | * Flush the existing macros. |
| 13308: | * |
| 13309: | * @return void |
| 13310: | * @static |
| 13311: | */ |
| 13312: | public static function flushMacros() |
| 13313: | { |
| 13314: | \Illuminate\Routing\Router::flushMacros(); |
| 13315: | } |
| 13316: | /** |
| 13317: | * Dynamically handle calls to the class. |
| 13318: | * |
| 13319: | * @param string $method |
| 13320: | * @param array $parameters |
| 13321: | * @return mixed |
| 13322: | * @throws \BadMethodCallException |
| 13323: | * @static |
| 13324: | */ |
| 13325: | public static function macroCall($method, $parameters) |
| 13326: | { |
| 13327: | /** @var \Illuminate\Routing\Router $instance */ |
| 13328: | return $instance->macroCall($method, $parameters); |
| 13329: | } |
| 13330: | |
| 13331: | } |
| 13332: | /** |
| 13333: | * |
| 13334: | * |
| 13335: | * @see \Illuminate\Database\Schema\Builder |
| 13336: | */ |
| 13337: | class Schema { |
| 13338: | /** |
| 13339: | * Create a database in the schema. |
| 13340: | * |
| 13341: | * @param string $name |
| 13342: | * @return bool |
| 13343: | * @static |
| 13344: | */ |
| 13345: | public static function createDatabase($name) |
| 13346: | { |
| 13347: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13348: | return $instance->createDatabase($name); |
| 13349: | } |
| 13350: | /** |
| 13351: | * Drop a database from the schema if the database exists. |
| 13352: | * |
| 13353: | * @param string $name |
| 13354: | * @return bool |
| 13355: | * @static |
| 13356: | */ |
| 13357: | public static function dropDatabaseIfExists($name) |
| 13358: | { |
| 13359: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13360: | return $instance->dropDatabaseIfExists($name); |
| 13361: | } |
| 13362: | /** |
| 13363: | * Determine if the given table exists. |
| 13364: | * |
| 13365: | * @param string $table |
| 13366: | * @return bool |
| 13367: | * @static |
| 13368: | */ |
| 13369: | public static function hasTable($table) |
| 13370: | { |
| 13371: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13372: | return $instance->hasTable($table); |
| 13373: | } |
| 13374: | /** |
| 13375: | * Get the column listing for a given table. |
| 13376: | * |
| 13377: | * @param string $table |
| 13378: | * @return array |
| 13379: | * @static |
| 13380: | */ |
| 13381: | public static function getColumnListing($table) |
| 13382: | { |
| 13383: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13384: | return $instance->getColumnListing($table); |
| 13385: | } |
| 13386: | /** |
| 13387: | * Drop all tables from the database. |
| 13388: | * |
| 13389: | * @return void |
| 13390: | * @static |
| 13391: | */ |
| 13392: | public static function dropAllTables() |
| 13393: | { |
| 13394: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13395: | $instance->dropAllTables(); |
| 13396: | } |
| 13397: | /** |
| 13398: | * Drop all views from the database. |
| 13399: | * |
| 13400: | * @return void |
| 13401: | * @static |
| 13402: | */ |
| 13403: | public static function dropAllViews() |
| 13404: | { |
| 13405: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13406: | $instance->dropAllViews(); |
| 13407: | } |
| 13408: | /** |
| 13409: | * Get all of the table names for the database. |
| 13410: | * |
| 13411: | * @return array |
| 13412: | * @static |
| 13413: | */ |
| 13414: | public static function getAllTables() |
| 13415: | { |
| 13416: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13417: | return $instance->getAllTables(); |
| 13418: | } |
| 13419: | /** |
| 13420: | * Get all of the view names for the database. |
| 13421: | * |
| 13422: | * @return array |
| 13423: | * @static |
| 13424: | */ |
| 13425: | public static function getAllViews() |
| 13426: | { |
| 13427: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13428: | return $instance->getAllViews(); |
| 13429: | } |
| 13430: | /** |
| 13431: | * Set the default string length for migrations. |
| 13432: | * |
| 13433: | * @param int $length |
| 13434: | * @return void |
| 13435: | * @static |
| 13436: | */ |
| 13437: | public static function defaultStringLength($length) |
| 13438: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13439: | \Illuminate\Database\Schema\MySqlBuilder::defaultStringLength($length); |
| 13440: | } |
| 13441: | /** |
| 13442: | * Set the default morph key type for migrations. |
| 13443: | * |
| 13444: | * @param string $type |
| 13445: | * @return void |
| 13446: | * @throws \InvalidArgumentException |
| 13447: | * @static |
| 13448: | */ |
| 13449: | public static function defaultMorphKeyType($type) |
| 13450: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13451: | \Illuminate\Database\Schema\MySqlBuilder::defaultMorphKeyType($type); |
| 13452: | } |
| 13453: | /** |
| 13454: | * Set the default morph key type for migrations to UUIDs. |
| 13455: | * |
| 13456: | * @return void |
| 13457: | * @static |
| 13458: | */ |
| 13459: | public static function morphUsingUuids() |
| 13460: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13461: | \Illuminate\Database\Schema\MySqlBuilder::morphUsingUuids(); |
| 13462: | } |
| 13463: | /** |
| 13464: | * Determine if the given table has a given column. |
| 13465: | * |
| 13466: | * @param string $table |
| 13467: | * @param string $column |
| 13468: | * @return bool |
| 13469: | * @static |
| 13470: | */ |
| 13471: | public static function hasColumn($table, $column) |
| 13472: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13473: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13474: | return $instance->hasColumn($table, $column); |
| 13475: | } |
| 13476: | /** |
| 13477: | * Determine if the given table has given columns. |
| 13478: | * |
| 13479: | * @param string $table |
| 13480: | * @param array $columns |
| 13481: | * @return bool |
| 13482: | * @static |
| 13483: | */ |
| 13484: | public static function hasColumns($table, $columns) |
| 13485: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13486: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13487: | return $instance->hasColumns($table, $columns); |
| 13488: | } |
| 13489: | /** |
| 13490: | * Execute a table builder callback if the given table has a given column. |
| 13491: | * |
| 13492: | * @param string $table |
| 13493: | * @param string $column |
| 13494: | * @param \Closure $callback |
| 13495: | * @return void |
| 13496: | * @static |
| 13497: | */ |
| 13498: | public static function whenTableHasColumn($table, $column, $callback) |
| 13499: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13500: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13501: | $instance->whenTableHasColumn($table, $column, $callback); |
| 13502: | } |
| 13503: | /** |
| 13504: | * Execute a table builder callback if the given table doesn't have a given column. |
| 13505: | * |
| 13506: | * @param string $table |
| 13507: | * @param string $column |
| 13508: | * @param \Closure $callback |
| 13509: | * @return void |
| 13510: | * @static |
| 13511: | */ |
| 13512: | public static function whenTableDoesntHaveColumn($table, $column, $callback) |
| 13513: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13514: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13515: | $instance->whenTableDoesntHaveColumn($table, $column, $callback); |
| 13516: | } |
| 13517: | /** |
| 13518: | * Get the data type for the given column name. |
| 13519: | * |
| 13520: | * @param string $table |
| 13521: | * @param string $column |
| 13522: | * @return string |
| 13523: | * @static |
| 13524: | */ |
| 13525: | public static function getColumnType($table, $column) |
| 13526: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13527: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13528: | return $instance->getColumnType($table, $column); |
| 13529: | } |
| 13530: | /** |
| 13531: | * Modify a table on the schema. |
| 13532: | * |
| 13533: | * @param string $table |
| 13534: | * @param \Closure $callback |
| 13535: | * @return void |
| 13536: | * @static |
| 13537: | */ |
| 13538: | public static function table($table, $callback) |
| 13539: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13540: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13541: | $instance->table($table, $callback); |
| 13542: | } |
| 13543: | /** |
| 13544: | * Create a new table on the schema. |
| 13545: | * |
| 13546: | * @param string $table |
| 13547: | * @param \Closure $callback |
| 13548: | * @return void |
| 13549: | * @static |
| 13550: | */ |
| 13551: | public static function create($table, $callback) |
| 13552: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13553: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13554: | $instance->create($table, $callback); |
| 13555: | } |
| 13556: | /** |
| 13557: | * Drop a table from the schema. |
| 13558: | * |
| 13559: | * @param string $table |
| 13560: | * @return void |
| 13561: | * @static |
| 13562: | */ |
| 13563: | public static function drop($table) |
| 13564: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13565: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13566: | $instance->drop($table); |
| 13567: | } |
| 13568: | /** |
| 13569: | * Drop a table from the schema if it exists. |
| 13570: | * |
| 13571: | * @param string $table |
| 13572: | * @return void |
| 13573: | * @static |
| 13574: | */ |
| 13575: | public static function dropIfExists($table) |
| 13576: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13577: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13578: | $instance->dropIfExists($table); |
| 13579: | } |
| 13580: | /** |
| 13581: | * Drop columns from a table schema. |
| 13582: | * |
| 13583: | * @param string $table |
| 13584: | * @param string|array $columns |
| 13585: | * @return void |
| 13586: | * @static |
| 13587: | */ |
| 13588: | public static function dropColumns($table, $columns) |
| 13589: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13590: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13591: | $instance->dropColumns($table, $columns); |
| 13592: | } |
| 13593: | /** |
| 13594: | * Drop all types from the database. |
| 13595: | * |
| 13596: | * @return void |
| 13597: | * @throws \LogicException |
| 13598: | * @static |
| 13599: | */ |
| 13600: | public static function dropAllTypes() |
| 13601: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13602: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13603: | $instance->dropAllTypes(); |
| 13604: | } |
| 13605: | /** |
| 13606: | * Rename a table on the schema. |
| 13607: | * |
| 13608: | * @param string $from |
| 13609: | * @param string $to |
| 13610: | * @return void |
| 13611: | * @static |
| 13612: | */ |
| 13613: | public static function rename($from, $to) |
| 13614: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13615: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13616: | $instance->rename($from, $to); |
| 13617: | } |
| 13618: | /** |
| 13619: | * Enable foreign key constraints. |
| 13620: | * |
| 13621: | * @return bool |
| 13622: | * @static |
| 13623: | */ |
| 13624: | public static function enableForeignKeyConstraints() |
| 13625: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13626: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13627: | return $instance->enableForeignKeyConstraints(); |
| 13628: | } |
| 13629: | /** |
| 13630: | * Disable foreign key constraints. |
| 13631: | * |
| 13632: | * @return bool |
| 13633: | * @static |
| 13634: | */ |
| 13635: | public static function disableForeignKeyConstraints() |
| 13636: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13637: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13638: | return $instance->disableForeignKeyConstraints(); |
| 13639: | } |
| 13640: | /** |
| 13641: | * Get the database connection instance. |
| 13642: | * |
| 13643: | * @return \Illuminate\Database\Connection |
| 13644: | * @static |
| 13645: | */ |
| 13646: | public static function getConnection() |
| 13647: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13648: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13649: | return $instance->getConnection(); |
| 13650: | } |
| 13651: | /** |
| 13652: | * Set the database connection instance. |
| 13653: | * |
| 13654: | * @param \Illuminate\Database\Connection $connection |
| 13655: | * @return \Illuminate\Database\Schema\MySqlBuilder |
| 13656: | * @static |
| 13657: | */ |
| 13658: | public static function setConnection($connection) |
| 13659: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13660: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13661: | return $instance->setConnection($connection); |
| 13662: | } |
| 13663: | /** |
| 13664: | * Set the Schema Blueprint resolver callback. |
| 13665: | * |
| 13666: | * @param \Closure $resolver |
| 13667: | * @return void |
| 13668: | * @static |
| 13669: | */ |
| 13670: | public static function blueprintResolver($resolver) |
| 13671: | { //Method inherited from \Illuminate\Database\Schema\Builder |
| 13672: | /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */ |
| 13673: | $instance->blueprintResolver($resolver); |
| 13674: | } |
| 13675: | |
| 13676: | } |
| 13677: | /** |
| 13678: | * |
| 13679: | * |
| 13680: | * @see \Illuminate\Session\SessionManager |
| 13681: | * @see \Illuminate\Session\Store |
| 13682: | */ |
| 13683: | class Session { |
| 13684: | /** |
| 13685: | * Determine if requests for the same session should wait for each to finish before executing. |
| 13686: | * |
| 13687: | * @return bool |
| 13688: | * @static |
| 13689: | */ |
| 13690: | public static function shouldBlock() |
| 13691: | { |
| 13692: | /** @var \Illuminate\Session\SessionManager $instance */ |
| 13693: | return $instance->shouldBlock(); |
| 13694: | } |
| 13695: | /** |
| 13696: | * Get the name of the cache store / driver that should be used to acquire session locks. |
| 13697: | * |
| 13698: | * @return string|null |
| 13699: | * @static |
| 13700: | */ |
| 13701: | public static function blockDriver() |
| 13702: | { |
| 13703: | /** @var \Illuminate\Session\SessionManager $instance */ |
| 13704: | return $instance->blockDriver(); |
| 13705: | } |
| 13706: | /** |
| 13707: | * Get the session configuration. |
| 13708: | * |
| 13709: | * @return array |
| 13710: | * @static |
| 13711: | */ |
| 13712: | public static function getSessionConfig() |
| 13713: | { |
| 13714: | /** @var \Illuminate\Session\SessionManager $instance */ |
| 13715: | return $instance->getSessionConfig(); |
| 13716: | } |
| 13717: | /** |
| 13718: | * Get the default session driver name. |
| 13719: | * |
| 13720: | * @return string |
| 13721: | * @static |
| 13722: | */ |
| 13723: | public static function getDefaultDriver() |
| 13724: | { |
| 13725: | /** @var \Illuminate\Session\SessionManager $instance */ |
| 13726: | return $instance->getDefaultDriver(); |
| 13727: | } |
| 13728: | /** |
| 13729: | * Set the default session driver name. |
| 13730: | * |
| 13731: | * @param string $name |
| 13732: | * @return void |
| 13733: | * @static |
| 13734: | */ |
| 13735: | public static function setDefaultDriver($name) |
| 13736: | { |
| 13737: | /** @var \Illuminate\Session\SessionManager $instance */ |
| 13738: | $instance->setDefaultDriver($name); |
| 13739: | } |
| 13740: | /** |
| 13741: | * Get a driver instance. |
| 13742: | * |
| 13743: | * @param string|null $driver |
| 13744: | * @return mixed |
| 13745: | * @throws \InvalidArgumentException |
| 13746: | * @static |
| 13747: | */ |
| 13748: | public static function driver($driver = null) |
| 13749: | { //Method inherited from \Illuminate\Support\Manager |
| 13750: | /** @var \Illuminate\Session\SessionManager $instance */ |
| 13751: | return $instance->driver($driver); |
| 13752: | } |
| 13753: | /** |
| 13754: | * Register a custom driver creator Closure. |
| 13755: | * |
| 13756: | * @param string $driver |
| 13757: | * @param \Closure $callback |
| 13758: | * @return \Illuminate\Session\SessionManager |
| 13759: | * @static |
| 13760: | */ |
| 13761: | public static function extend($driver, $callback) |
| 13762: | { //Method inherited from \Illuminate\Support\Manager |
| 13763: | /** @var \Illuminate\Session\SessionManager $instance */ |
| 13764: | return $instance->extend($driver, $callback); |
| 13765: | } |
| 13766: | /** |
| 13767: | * Get all of the created "drivers". |
| 13768: | * |
| 13769: | * @return array |
| 13770: | * @static |
| 13771: | */ |
| 13772: | public static function getDrivers() |
| 13773: | { //Method inherited from \Illuminate\Support\Manager |
| 13774: | /** @var \Illuminate\Session\SessionManager $instance */ |
| 13775: | return $instance->getDrivers(); |
| 13776: | } |
| 13777: | /** |
| 13778: | * Get the container instance used by the manager. |
| 13779: | * |
| 13780: | * @return \Illuminate\Contracts\Container\Container |
| 13781: | * @static |
| 13782: | */ |
| 13783: | public static function getContainer() |
| 13784: | { //Method inherited from \Illuminate\Support\Manager |
| 13785: | /** @var \Illuminate\Session\SessionManager $instance */ |
| 13786: | return $instance->getContainer(); |
| 13787: | } |
| 13788: | /** |
| 13789: | * Set the container instance used by the manager. |
| 13790: | * |
| 13791: | * @param \Illuminate\Contracts\Container\Container $container |
| 13792: | * @return \Illuminate\Session\SessionManager |
| 13793: | * @static |
| 13794: | */ |
| 13795: | public static function setContainer($container) |
| 13796: | { //Method inherited from \Illuminate\Support\Manager |
| 13797: | /** @var \Illuminate\Session\SessionManager $instance */ |
| 13798: | return $instance->setContainer($container); |
| 13799: | } |
| 13800: | /** |
| 13801: | * Forget all of the resolved driver instances. |
| 13802: | * |
| 13803: | * @return \Illuminate\Session\SessionManager |
| 13804: | * @static |
| 13805: | */ |
| 13806: | public static function forgetDrivers() |
| 13807: | { //Method inherited from \Illuminate\Support\Manager |
| 13808: | /** @var \Illuminate\Session\SessionManager $instance */ |
| 13809: | return $instance->forgetDrivers(); |
| 13810: | } |
| 13811: | /** |
| 13812: | * Start the session, reading the data from a handler. |
| 13813: | * |
| 13814: | * @return bool |
| 13815: | * @static |
| 13816: | */ |
| 13817: | public static function start() |
| 13818: | { |
| 13819: | /** @var \Illuminate\Session\Store $instance */ |
| 13820: | return $instance->start(); |
| 13821: | } |
| 13822: | /** |
| 13823: | * Save the session data to storage. |
| 13824: | * |
| 13825: | * @return void |
| 13826: | * @static |
| 13827: | */ |
| 13828: | public static function save() |
| 13829: | { |
| 13830: | /** @var \Illuminate\Session\Store $instance */ |
| 13831: | $instance->save(); |
| 13832: | } |
| 13833: | /** |
| 13834: | * Age the flash data for the session. |
| 13835: | * |
| 13836: | * @return void |
| 13837: | * @static |
| 13838: | */ |
| 13839: | public static function ageFlashData() |
| 13840: | { |
| 13841: | /** @var \Illuminate\Session\Store $instance */ |
| 13842: | $instance->ageFlashData(); |
| 13843: | } |
| 13844: | /** |
| 13845: | * Get all of the session data. |
| 13846: | * |
| 13847: | * @return array |
| 13848: | * @static |
| 13849: | */ |
| 13850: | public static function all() |
| 13851: | { |
| 13852: | /** @var \Illuminate\Session\Store $instance */ |
| 13853: | return $instance->all(); |
| 13854: | } |
| 13855: | /** |
| 13856: | * Get a subset of the session data. |
| 13857: | * |
| 13858: | * @param array $keys |
| 13859: | * @return array |
| 13860: | * @static |
| 13861: | */ |
| 13862: | public static function only($keys) |
| 13863: | { |
| 13864: | /** @var \Illuminate\Session\Store $instance */ |
| 13865: | return $instance->only($keys); |
| 13866: | } |
| 13867: | /** |
| 13868: | * Checks if a key exists. |
| 13869: | * |
| 13870: | * @param string|array $key |
| 13871: | * @return bool |
| 13872: | * @static |
| 13873: | */ |
| 13874: | public static function exists($key) |
| 13875: | { |
| 13876: | /** @var \Illuminate\Session\Store $instance */ |
| 13877: | return $instance->exists($key); |
| 13878: | } |
| 13879: | /** |
| 13880: | * Determine if the given key is missing from the session data. |
| 13881: | * |
| 13882: | * @param string|array $key |
| 13883: | * @return bool |
| 13884: | * @static |
| 13885: | */ |
| 13886: | public static function missing($key) |
| 13887: | { |
| 13888: | /** @var \Illuminate\Session\Store $instance */ |
| 13889: | return $instance->missing($key); |
| 13890: | } |
| 13891: | /** |
| 13892: | * Checks if a key is present and not null. |
| 13893: | * |
| 13894: | * @param string|array $key |
| 13895: | * @return bool |
| 13896: | * @static |
| 13897: | */ |
| 13898: | public static function has($key) |
| 13899: | { |
| 13900: | /** @var \Illuminate\Session\Store $instance */ |
| 13901: | return $instance->has($key); |
| 13902: | } |
| 13903: | /** |
| 13904: | * Get an item from the session. |
| 13905: | * |
| 13906: | * @param string $key |
| 13907: | * @param mixed $default |
| 13908: | * @return mixed |
| 13909: | * @static |
| 13910: | */ |
| 13911: | public static function get($key, $default = null) |
| 13912: | { |
| 13913: | /** @var \Illuminate\Session\Store $instance */ |
| 13914: | return $instance->get($key, $default); |
| 13915: | } |
| 13916: | /** |
| 13917: | * Get the value of a given key and then forget it. |
| 13918: | * |
| 13919: | * @param string $key |
| 13920: | * @param mixed $default |
| 13921: | * @return mixed |
| 13922: | * @static |
| 13923: | */ |
| 13924: | public static function pull($key, $default = null) |
| 13925: | { |
| 13926: | /** @var \Illuminate\Session\Store $instance */ |
| 13927: | return $instance->pull($key, $default); |
| 13928: | } |
| 13929: | /** |
| 13930: | * Determine if the session contains old input. |
| 13931: | * |
| 13932: | * @param string|null $key |
| 13933: | * @return bool |
| 13934: | * @static |
| 13935: | */ |
| 13936: | public static function hasOldInput($key = null) |
| 13937: | { |
| 13938: | /** @var \Illuminate\Session\Store $instance */ |
| 13939: | return $instance->hasOldInput($key); |
| 13940: | } |
| 13941: | /** |
| 13942: | * Get the requested item from the flashed input array. |
| 13943: | * |
| 13944: | * @param string|null $key |
| 13945: | * @param mixed $default |
| 13946: | * @return mixed |
| 13947: | * @static |
| 13948: | */ |
| 13949: | public static function getOldInput($key = null, $default = null) |
| 13950: | { |
| 13951: | /** @var \Illuminate\Session\Store $instance */ |
| 13952: | return $instance->getOldInput($key, $default); |
| 13953: | } |
| 13954: | /** |
| 13955: | * Replace the given session attributes entirely. |
| 13956: | * |
| 13957: | * @param array $attributes |
| 13958: | * @return void |
| 13959: | * @static |
| 13960: | */ |
| 13961: | public static function replace($attributes) |
| 13962: | { |
| 13963: | /** @var \Illuminate\Session\Store $instance */ |
| 13964: | $instance->replace($attributes); |
| 13965: | } |
| 13966: | /** |
| 13967: | * Put a key / value pair or array of key / value pairs in the session. |
| 13968: | * |
| 13969: | * @param string|array $key |
| 13970: | * @param mixed $value |
| 13971: | * @return void |
| 13972: | * @static |
| 13973: | */ |
| 13974: | public static function put($key, $value = null) |
| 13975: | { |
| 13976: | /** @var \Illuminate\Session\Store $instance */ |
| 13977: | $instance->put($key, $value); |
| 13978: | } |
| 13979: | /** |
| 13980: | * Get an item from the session, or store the default value. |
| 13981: | * |
| 13982: | * @param string $key |
| 13983: | * @param \Closure $callback |
| 13984: | * @return mixed |
| 13985: | * @static |
| 13986: | */ |
| 13987: | public static function remember($key, $callback) |
| 13988: | { |
| 13989: | /** @var \Illuminate\Session\Store $instance */ |
| 13990: | return $instance->remember($key, $callback); |
| 13991: | } |
| 13992: | /** |
| 13993: | * Push a value onto a session array. |
| 13994: | * |
| 13995: | * @param string $key |
| 13996: | * @param mixed $value |
| 13997: | * @return void |
| 13998: | * @static |
| 13999: | */ |
| 14000: | public static function push($key, $value) |
| 14001: | { |
| 14002: | /** @var \Illuminate\Session\Store $instance */ |
| 14003: | $instance->push($key, $value); |
| 14004: | } |
| 14005: | /** |
| 14006: | * Increment the value of an item in the session. |
| 14007: | * |
| 14008: | * @param string $key |
| 14009: | * @param int $amount |
| 14010: | * @return mixed |
| 14011: | * @static |
| 14012: | */ |
| 14013: | public static function increment($key, $amount = 1) |
| 14014: | { |
| 14015: | /** @var \Illuminate\Session\Store $instance */ |
| 14016: | return $instance->increment($key, $amount); |
| 14017: | } |
| 14018: | /** |
| 14019: | * Decrement the value of an item in the session. |
| 14020: | * |
| 14021: | * @param string $key |
| 14022: | * @param int $amount |
| 14023: | * @return int |
| 14024: | * @static |
| 14025: | */ |
| 14026: | public static function decrement($key, $amount = 1) |
| 14027: | { |
| 14028: | /** @var \Illuminate\Session\Store $instance */ |
| 14029: | return $instance->decrement($key, $amount); |
| 14030: | } |
| 14031: | /** |
| 14032: | * Flash a key / value pair to the session. |
| 14033: | * |
| 14034: | * @param string $key |
| 14035: | * @param mixed $value |
| 14036: | * @return void |
| 14037: | * @static |
| 14038: | */ |
| 14039: | public static function flash($key, $value = true) |
| 14040: | { |
| 14041: | /** @var \Illuminate\Session\Store $instance */ |
| 14042: | $instance->flash($key, $value); |
| 14043: | } |
| 14044: | /** |
| 14045: | * Flash a key / value pair to the session for immediate use. |
| 14046: | * |
| 14047: | * @param string $key |
| 14048: | * @param mixed $value |
| 14049: | * @return void |
| 14050: | * @static |
| 14051: | */ |
| 14052: | public static function now($key, $value) |
| 14053: | { |
| 14054: | /** @var \Illuminate\Session\Store $instance */ |
| 14055: | $instance->now($key, $value); |
| 14056: | } |
| 14057: | /** |
| 14058: | * Reflash all of the session flash data. |
| 14059: | * |
| 14060: | * @return void |
| 14061: | * @static |
| 14062: | */ |
| 14063: | public static function reflash() |
| 14064: | { |
| 14065: | /** @var \Illuminate\Session\Store $instance */ |
| 14066: | $instance->reflash(); |
| 14067: | } |
| 14068: | /** |
| 14069: | * Reflash a subset of the current flash data. |
| 14070: | * |
| 14071: | * @param array|mixed $keys |
| 14072: | * @return void |
| 14073: | * @static |
| 14074: | */ |
| 14075: | public static function keep($keys = null) |
| 14076: | { |
| 14077: | /** @var \Illuminate\Session\Store $instance */ |
| 14078: | $instance->keep($keys); |
| 14079: | } |
| 14080: | /** |
| 14081: | * Flash an input array to the session. |
| 14082: | * |
| 14083: | * @param array $value |
| 14084: | * @return void |
| 14085: | * @static |
| 14086: | */ |
| 14087: | public static function flashInput($value) |
| 14088: | { |
| 14089: | /** @var \Illuminate\Session\Store $instance */ |
| 14090: | $instance->flashInput($value); |
| 14091: | } |
| 14092: | /** |
| 14093: | * Remove an item from the session, returning its value. |
| 14094: | * |
| 14095: | * @param string $key |
| 14096: | * @return mixed |
| 14097: | * @static |
| 14098: | */ |
| 14099: | public static function remove($key) |
| 14100: | { |
| 14101: | /** @var \Illuminate\Session\Store $instance */ |
| 14102: | return $instance->remove($key); |
| 14103: | } |
| 14104: | /** |
| 14105: | * Remove one or many items from the session. |
| 14106: | * |
| 14107: | * @param string|array $keys |
| 14108: | * @return void |
| 14109: | * @static |
| 14110: | */ |
| 14111: | public static function forget($keys) |
| 14112: | { |
| 14113: | /** @var \Illuminate\Session\Store $instance */ |
| 14114: | $instance->forget($keys); |
| 14115: | } |
| 14116: | /** |
| 14117: | * Remove all of the items from the session. |
| 14118: | * |
| 14119: | * @return void |
| 14120: | * @static |
| 14121: | */ |
| 14122: | public static function flush() |
| 14123: | { |
| 14124: | /** @var \Illuminate\Session\Store $instance */ |
| 14125: | $instance->flush(); |
| 14126: | } |
| 14127: | /** |
| 14128: | * Flush the session data and regenerate the ID. |
| 14129: | * |
| 14130: | * @return bool |
| 14131: | * @static |
| 14132: | */ |
| 14133: | public static function invalidate() |
| 14134: | { |
| 14135: | /** @var \Illuminate\Session\Store $instance */ |
| 14136: | return $instance->invalidate(); |
| 14137: | } |
| 14138: | /** |
| 14139: | * Generate a new session identifier. |
| 14140: | * |
| 14141: | * @param bool $destroy |
| 14142: | * @return bool |
| 14143: | * @static |
| 14144: | */ |
| 14145: | public static function regenerate($destroy = false) |
| 14146: | { |
| 14147: | /** @var \Illuminate\Session\Store $instance */ |
| 14148: | return $instance->regenerate($destroy); |
| 14149: | } |
| 14150: | /** |
| 14151: | * Generate a new session ID for the session. |
| 14152: | * |
| 14153: | * @param bool $destroy |
| 14154: | * @return bool |
| 14155: | * @static |
| 14156: | */ |
| 14157: | public static function migrate($destroy = false) |
| 14158: | { |
| 14159: | /** @var \Illuminate\Session\Store $instance */ |
| 14160: | return $instance->migrate($destroy); |
| 14161: | } |
| 14162: | /** |
| 14163: | * Determine if the session has been started. |
| 14164: | * |
| 14165: | * @return bool |
| 14166: | * @static |
| 14167: | */ |
| 14168: | public static function isStarted() |
| 14169: | { |
| 14170: | /** @var \Illuminate\Session\Store $instance */ |
| 14171: | return $instance->isStarted(); |
| 14172: | } |
| 14173: | /** |
| 14174: | * Get the name of the session. |
| 14175: | * |
| 14176: | * @return string |
| 14177: | * @static |
| 14178: | */ |
| 14179: | public static function getName() |
| 14180: | { |
| 14181: | /** @var \Illuminate\Session\Store $instance */ |
| 14182: | return $instance->getName(); |
| 14183: | } |
| 14184: | /** |
| 14185: | * Set the name of the session. |
| 14186: | * |
| 14187: | * @param string $name |
| 14188: | * @return void |
| 14189: | * @static |
| 14190: | */ |
| 14191: | public static function setName($name) |
| 14192: | { |
| 14193: | /** @var \Illuminate\Session\Store $instance */ |
| 14194: | $instance->setName($name); |
| 14195: | } |
| 14196: | /** |
| 14197: | * Get the current session ID. |
| 14198: | * |
| 14199: | * @return string |
| 14200: | * @static |
| 14201: | */ |
| 14202: | public static function getId() |
| 14203: | { |
| 14204: | /** @var \Illuminate\Session\Store $instance */ |
| 14205: | return $instance->getId(); |
| 14206: | } |
| 14207: | /** |
| 14208: | * Set the session ID. |
| 14209: | * |
| 14210: | * @param string $id |
| 14211: | * @return void |
| 14212: | * @static |
| 14213: | */ |
| 14214: | public static function setId($id) |
| 14215: | { |
| 14216: | /** @var \Illuminate\Session\Store $instance */ |
| 14217: | $instance->setId($id); |
| 14218: | } |
| 14219: | /** |
| 14220: | * Determine if this is a valid session ID. |
| 14221: | * |
| 14222: | * @param string $id |
| 14223: | * @return bool |
| 14224: | * @static |
| 14225: | */ |
| 14226: | public static function isValidId($id) |
| 14227: | { |
| 14228: | /** @var \Illuminate\Session\Store $instance */ |
| 14229: | return $instance->isValidId($id); |
| 14230: | } |
| 14231: | /** |
| 14232: | * Set the existence of the session on the handler if applicable. |
| 14233: | * |
| 14234: | * @param bool $value |
| 14235: | * @return void |
| 14236: | * @static |
| 14237: | */ |
| 14238: | public static function setExists($value) |
| 14239: | { |
| 14240: | /** @var \Illuminate\Session\Store $instance */ |
| 14241: | $instance->setExists($value); |
| 14242: | } |
| 14243: | /** |
| 14244: | * Get the CSRF token value. |
| 14245: | * |
| 14246: | * @return string |
| 14247: | * @static |
| 14248: | */ |
| 14249: | public static function token() |
| 14250: | { |
| 14251: | /** @var \Illuminate\Session\Store $instance */ |
| 14252: | return $instance->token(); |
| 14253: | } |
| 14254: | /** |
| 14255: | * Regenerate the CSRF token value. |
| 14256: | * |
| 14257: | * @return void |
| 14258: | * @static |
| 14259: | */ |
| 14260: | public static function regenerateToken() |
| 14261: | { |
| 14262: | /** @var \Illuminate\Session\Store $instance */ |
| 14263: | $instance->regenerateToken(); |
| 14264: | } |
| 14265: | /** |
| 14266: | * Get the previous URL from the session. |
| 14267: | * |
| 14268: | * @return string|null |
| 14269: | * @static |
| 14270: | */ |
| 14271: | public static function previousUrl() |
| 14272: | { |
| 14273: | /** @var \Illuminate\Session\Store $instance */ |
| 14274: | return $instance->previousUrl(); |
| 14275: | } |
| 14276: | /** |
| 14277: | * Set the "previous" URL in the session. |
| 14278: | * |
| 14279: | * @param string $url |
| 14280: | * @return void |
| 14281: | * @static |
| 14282: | */ |
| 14283: | public static function setPreviousUrl($url) |
| 14284: | { |
| 14285: | /** @var \Illuminate\Session\Store $instance */ |
| 14286: | $instance->setPreviousUrl($url); |
| 14287: | } |
| 14288: | /** |
| 14289: | * Specify that the user has confirmed their password. |
| 14290: | * |
| 14291: | * @return void |
| 14292: | * @static |
| 14293: | */ |
| 14294: | public static function passwordConfirmed() |
| 14295: | { |
| 14296: | /** @var \Illuminate\Session\Store $instance */ |
| 14297: | $instance->passwordConfirmed(); |
| 14298: | } |
| 14299: | /** |
| 14300: | * Get the underlying session handler implementation. |
| 14301: | * |
| 14302: | * @return \SessionHandlerInterface |
| 14303: | * @static |
| 14304: | */ |
| 14305: | public static function getHandler() |
| 14306: | { |
| 14307: | /** @var \Illuminate\Session\Store $instance */ |
| 14308: | return $instance->getHandler(); |
| 14309: | } |
| 14310: | /** |
| 14311: | * Determine if the session handler needs a request. |
| 14312: | * |
| 14313: | * @return bool |
| 14314: | * @static |
| 14315: | */ |
| 14316: | public static function handlerNeedsRequest() |
| 14317: | { |
| 14318: | /** @var \Illuminate\Session\Store $instance */ |
| 14319: | return $instance->handlerNeedsRequest(); |
| 14320: | } |
| 14321: | /** |
| 14322: | * Set the request on the handler instance. |
| 14323: | * |
| 14324: | * @param \Illuminate\Http\Request $request |
| 14325: | * @return void |
| 14326: | * @static |
| 14327: | */ |
| 14328: | public static function setRequestOnHandler($request) |
| 14329: | { |
| 14330: | /** @var \Illuminate\Session\Store $instance */ |
| 14331: | $instance->setRequestOnHandler($request); |
| 14332: | } |
| 14333: | |
| 14334: | } |
| 14335: | /** |
| 14336: | * |
| 14337: | * |
| 14338: | * @see \Illuminate\Filesystem\FilesystemManager |
| 14339: | */ |
| 14340: | class Storage { |
| 14341: | /** |
| 14342: | * Get a filesystem instance. |
| 14343: | * |
| 14344: | * @param string|null $name |
| 14345: | * @return \Illuminate\Filesystem\FilesystemAdapter |
| 14346: | * @static |
| 14347: | */ |
| 14348: | public static function drive($name = null) |
| 14349: | { |
| 14350: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14351: | return $instance->drive($name); |
| 14352: | } |
| 14353: | /** |
| 14354: | * Get a filesystem instance. |
| 14355: | * |
| 14356: | * @param string|null $name |
| 14357: | * @return \Illuminate\Filesystem\FilesystemAdapter |
| 14358: | * @static |
| 14359: | */ |
| 14360: | public static function disk($name = null) |
| 14361: | { |
| 14362: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14363: | return $instance->disk($name); |
| 14364: | } |
| 14365: | /** |
| 14366: | * Get a default cloud filesystem instance. |
| 14367: | * |
| 14368: | * @return \Illuminate\Filesystem\FilesystemAdapter |
| 14369: | * @static |
| 14370: | */ |
| 14371: | public static function cloud() |
| 14372: | { |
| 14373: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14374: | return $instance->cloud(); |
| 14375: | } |
| 14376: | /** |
| 14377: | * Build an on-demand disk. |
| 14378: | * |
| 14379: | * @param string|array $config |
| 14380: | * @return \Illuminate\Filesystem\FilesystemAdapter |
| 14381: | * @static |
| 14382: | */ |
| 14383: | public static function build($config) |
| 14384: | { |
| 14385: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14386: | return $instance->build($config); |
| 14387: | } |
| 14388: | /** |
| 14389: | * Create an instance of the local driver. |
| 14390: | * |
| 14391: | * @param array $config |
| 14392: | * @return \Illuminate\Filesystem\FilesystemAdapter |
| 14393: | * @static |
| 14394: | */ |
| 14395: | public static function createLocalDriver($config) |
| 14396: | { |
| 14397: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14398: | return $instance->createLocalDriver($config); |
| 14399: | } |
| 14400: | /** |
| 14401: | * Create an instance of the ftp driver. |
| 14402: | * |
| 14403: | * @param array $config |
| 14404: | * @return \Illuminate\Filesystem\FilesystemAdapter |
| 14405: | * @static |
| 14406: | */ |
| 14407: | public static function createFtpDriver($config) |
| 14408: | { |
| 14409: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14410: | return $instance->createFtpDriver($config); |
| 14411: | } |
| 14412: | /** |
| 14413: | * Create an instance of the sftp driver. |
| 14414: | * |
| 14415: | * @param array $config |
| 14416: | * @return \Illuminate\Filesystem\FilesystemAdapter |
| 14417: | * @static |
| 14418: | */ |
| 14419: | public static function createSftpDriver($config) |
| 14420: | { |
| 14421: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14422: | return $instance->createSftpDriver($config); |
| 14423: | } |
| 14424: | /** |
| 14425: | * Create an instance of the Amazon S3 driver. |
| 14426: | * |
| 14427: | * @param array $config |
| 14428: | * @return \Illuminate\Contracts\Filesystem\Cloud |
| 14429: | * @static |
| 14430: | */ |
| 14431: | public static function createS3Driver($config) |
| 14432: | { |
| 14433: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14434: | return $instance->createS3Driver($config); |
| 14435: | } |
| 14436: | /** |
| 14437: | * Set the given disk instance. |
| 14438: | * |
| 14439: | * @param string $name |
| 14440: | * @param mixed $disk |
| 14441: | * @return \Illuminate\Filesystem\FilesystemManager |
| 14442: | * @static |
| 14443: | */ |
| 14444: | public static function set($name, $disk) |
| 14445: | { |
| 14446: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14447: | return $instance->set($name, $disk); |
| 14448: | } |
| 14449: | /** |
| 14450: | * Get the default driver name. |
| 14451: | * |
| 14452: | * @return string |
| 14453: | * @static |
| 14454: | */ |
| 14455: | public static function getDefaultDriver() |
| 14456: | { |
| 14457: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14458: | return $instance->getDefaultDriver(); |
| 14459: | } |
| 14460: | /** |
| 14461: | * Get the default cloud driver name. |
| 14462: | * |
| 14463: | * @return string |
| 14464: | * @static |
| 14465: | */ |
| 14466: | public static function getDefaultCloudDriver() |
| 14467: | { |
| 14468: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14469: | return $instance->getDefaultCloudDriver(); |
| 14470: | } |
| 14471: | /** |
| 14472: | * Unset the given disk instances. |
| 14473: | * |
| 14474: | * @param array|string $disk |
| 14475: | * @return \Illuminate\Filesystem\FilesystemManager |
| 14476: | * @static |
| 14477: | */ |
| 14478: | public static function forgetDisk($disk) |
| 14479: | { |
| 14480: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14481: | return $instance->forgetDisk($disk); |
| 14482: | } |
| 14483: | /** |
| 14484: | * Disconnect the given disk and remove from local cache. |
| 14485: | * |
| 14486: | * @param string|null $name |
| 14487: | * @return void |
| 14488: | * @static |
| 14489: | */ |
| 14490: | public static function purge($name = null) |
| 14491: | { |
| 14492: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14493: | $instance->purge($name); |
| 14494: | } |
| 14495: | /** |
| 14496: | * Register a custom driver creator Closure. |
| 14497: | * |
| 14498: | * @param string $driver |
| 14499: | * @param \Closure $callback |
| 14500: | * @return \Illuminate\Filesystem\FilesystemManager |
| 14501: | * @static |
| 14502: | */ |
| 14503: | public static function extend($driver, $callback) |
| 14504: | { |
| 14505: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14506: | return $instance->extend($driver, $callback); |
| 14507: | } |
| 14508: | /** |
| 14509: | * Set the application instance used by the manager. |
| 14510: | * |
| 14511: | * @param \Illuminate\Contracts\Foundation\Application $app |
| 14512: | * @return \Illuminate\Filesystem\FilesystemManager |
| 14513: | * @static |
| 14514: | */ |
| 14515: | public static function setApplication($app) |
| 14516: | { |
| 14517: | /** @var \Illuminate\Filesystem\FilesystemManager $instance */ |
| 14518: | return $instance->setApplication($app); |
| 14519: | } |
| 14520: | /** |
| 14521: | * Assert that the given file or directory exists. |
| 14522: | * |
| 14523: | * @param string|array $path |
| 14524: | * @param string|null $content |
| 14525: | * @return \Illuminate\Filesystem\FilesystemAdapter |
| 14526: | * @static |
| 14527: | */ |
| 14528: | public static function assertExists($path, $content = null) |
| 14529: | { |
| 14530: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14531: | return $instance->assertExists($path, $content); |
| 14532: | } |
| 14533: | /** |
| 14534: | * Assert that the given file or directory does not exist. |
| 14535: | * |
| 14536: | * @param string|array $path |
| 14537: | * @return \Illuminate\Filesystem\FilesystemAdapter |
| 14538: | * @static |
| 14539: | */ |
| 14540: | public static function assertMissing($path) |
| 14541: | { |
| 14542: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14543: | return $instance->assertMissing($path); |
| 14544: | } |
| 14545: | /** |
| 14546: | * Assert that the given directory is empty. |
| 14547: | * |
| 14548: | * @param string $path |
| 14549: | * @return \Illuminate\Filesystem\FilesystemAdapter |
| 14550: | * @static |
| 14551: | */ |
| 14552: | public static function assertDirectoryEmpty($path) |
| 14553: | { |
| 14554: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14555: | return $instance->assertDirectoryEmpty($path); |
| 14556: | } |
| 14557: | /** |
| 14558: | * Determine if a file or directory exists. |
| 14559: | * |
| 14560: | * @param string $path |
| 14561: | * @return bool |
| 14562: | * @static |
| 14563: | */ |
| 14564: | public static function exists($path) |
| 14565: | { |
| 14566: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14567: | return $instance->exists($path); |
| 14568: | } |
| 14569: | /** |
| 14570: | * Determine if a file or directory is missing. |
| 14571: | * |
| 14572: | * @param string $path |
| 14573: | * @return bool |
| 14574: | * @static |
| 14575: | */ |
| 14576: | public static function missing($path) |
| 14577: | { |
| 14578: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14579: | return $instance->missing($path); |
| 14580: | } |
| 14581: | /** |
| 14582: | * Determine if a file exists. |
| 14583: | * |
| 14584: | * @param string $path |
| 14585: | * @return bool |
| 14586: | * @static |
| 14587: | */ |
| 14588: | public static function fileExists($path) |
| 14589: | { |
| 14590: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14591: | return $instance->fileExists($path); |
| 14592: | } |
| 14593: | /** |
| 14594: | * Determine if a file is missing. |
| 14595: | * |
| 14596: | * @param string $path |
| 14597: | * @return bool |
| 14598: | * @static |
| 14599: | */ |
| 14600: | public static function fileMissing($path) |
| 14601: | { |
| 14602: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14603: | return $instance->fileMissing($path); |
| 14604: | } |
| 14605: | /** |
| 14606: | * Determine if a directory exists. |
| 14607: | * |
| 14608: | * @param string $path |
| 14609: | * @return bool |
| 14610: | * @static |
| 14611: | */ |
| 14612: | public static function directoryExists($path) |
| 14613: | { |
| 14614: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14615: | return $instance->directoryExists($path); |
| 14616: | } |
| 14617: | /** |
| 14618: | * Determine if a directory is missing. |
| 14619: | * |
| 14620: | * @param string $path |
| 14621: | * @return bool |
| 14622: | * @static |
| 14623: | */ |
| 14624: | public static function directoryMissing($path) |
| 14625: | { |
| 14626: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14627: | return $instance->directoryMissing($path); |
| 14628: | } |
| 14629: | /** |
| 14630: | * Get the full path for the file at the given "short" path. |
| 14631: | * |
| 14632: | * @param string $path |
| 14633: | * @return string |
| 14634: | * @static |
| 14635: | */ |
| 14636: | public static function path($path) |
| 14637: | { |
| 14638: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14639: | return $instance->path($path); |
| 14640: | } |
| 14641: | /** |
| 14642: | * Get the contents of a file. |
| 14643: | * |
| 14644: | * @param string $path |
| 14645: | * @return string|null |
| 14646: | * @static |
| 14647: | */ |
| 14648: | public static function get($path) |
| 14649: | { |
| 14650: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14651: | return $instance->get($path); |
| 14652: | } |
| 14653: | /** |
| 14654: | * Create a streamed response for a given file. |
| 14655: | * |
| 14656: | * @param string $path |
| 14657: | * @param string|null $name |
| 14658: | * @param array $headers |
| 14659: | * @param string|null $disposition |
| 14660: | * @return \Symfony\Component\HttpFoundation\StreamedResponse |
| 14661: | * @static |
| 14662: | */ |
| 14663: | public static function response($path, $name = null, $headers = [], $disposition = 'inline') |
| 14664: | { |
| 14665: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14666: | return $instance->response($path, $name, $headers, $disposition); |
| 14667: | } |
| 14668: | /** |
| 14669: | * Create a streamed download response for a given file. |
| 14670: | * |
| 14671: | * @param string $path |
| 14672: | * @param string|null $name |
| 14673: | * @return \Symfony\Component\HttpFoundation\StreamedResponse |
| 14674: | * @static |
| 14675: | */ |
| 14676: | public static function download($path, $name = null, $headers = []) |
| 14677: | { |
| 14678: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14679: | return $instance->download($path, $name, $headers); |
| 14680: | } |
| 14681: | /** |
| 14682: | * Write the contents of a file. |
| 14683: | * |
| 14684: | * @param string $path |
| 14685: | * @param \Psr\Http\Message\StreamInterface|\Illuminate\Http\File|\Illuminate\Http\UploadedFile|string|resource $contents |
| 14686: | * @param mixed $options |
| 14687: | * @return string|bool |
| 14688: | * @static |
| 14689: | */ |
| 14690: | public static function put($path, $contents, $options = []) |
| 14691: | { |
| 14692: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14693: | return $instance->put($path, $contents, $options); |
| 14694: | } |
| 14695: | /** |
| 14696: | * Store the uploaded file on the disk. |
| 14697: | * |
| 14698: | * @param string $path |
| 14699: | * @param \Illuminate\Http\File|\Illuminate\Http\UploadedFile|string $file |
| 14700: | * @param mixed $options |
| 14701: | * @return string|false |
| 14702: | * @static |
| 14703: | */ |
| 14704: | public static function putFile($path, $file, $options = []) |
| 14705: | { |
| 14706: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14707: | return $instance->putFile($path, $file, $options); |
| 14708: | } |
| 14709: | /** |
| 14710: | * Store the uploaded file on the disk with a given name. |
| 14711: | * |
| 14712: | * @param string $path |
| 14713: | * @param \Illuminate\Http\File|\Illuminate\Http\UploadedFile|string $file |
| 14714: | * @param string $name |
| 14715: | * @param mixed $options |
| 14716: | * @return string|false |
| 14717: | * @static |
| 14718: | */ |
| 14719: | public static function putFileAs($path, $file, $name, $options = []) |
| 14720: | { |
| 14721: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14722: | return $instance->putFileAs($path, $file, $name, $options); |
| 14723: | } |
| 14724: | /** |
| 14725: | * Get the visibility for the given path. |
| 14726: | * |
| 14727: | * @param string $path |
| 14728: | * @return string |
| 14729: | * @static |
| 14730: | */ |
| 14731: | public static function getVisibility($path) |
| 14732: | { |
| 14733: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14734: | return $instance->getVisibility($path); |
| 14735: | } |
| 14736: | /** |
| 14737: | * Set the visibility for the given path. |
| 14738: | * |
| 14739: | * @param string $path |
| 14740: | * @param string $visibility |
| 14741: | * @return bool |
| 14742: | * @static |
| 14743: | */ |
| 14744: | public static function setVisibility($path, $visibility) |
| 14745: | { |
| 14746: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14747: | return $instance->setVisibility($path, $visibility); |
| 14748: | } |
| 14749: | /** |
| 14750: | * Prepend to a file. |
| 14751: | * |
| 14752: | * @param string $path |
| 14753: | * @param string $data |
| 14754: | * @param string $separator |
| 14755: | * @return bool |
| 14756: | * @static |
| 14757: | */ |
| 14758: | public static function prepend($path, $data, $separator = ' |
| 14759: | ') |
| 14760: | { |
| 14761: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14762: | return $instance->prepend($path, $data, $separator); |
| 14763: | } |
| 14764: | /** |
| 14765: | * Append to a file. |
| 14766: | * |
| 14767: | * @param string $path |
| 14768: | * @param string $data |
| 14769: | * @param string $separator |
| 14770: | * @return bool |
| 14771: | * @static |
| 14772: | */ |
| 14773: | public static function append($path, $data, $separator = ' |
| 14774: | ') |
| 14775: | { |
| 14776: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14777: | return $instance->append($path, $data, $separator); |
| 14778: | } |
| 14779: | /** |
| 14780: | * Delete the file at a given path. |
| 14781: | * |
| 14782: | * @param string|array $paths |
| 14783: | * @return bool |
| 14784: | * @static |
| 14785: | */ |
| 14786: | public static function delete($paths) |
| 14787: | { |
| 14788: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14789: | return $instance->delete($paths); |
| 14790: | } |
| 14791: | /** |
| 14792: | * Copy a file to a new location. |
| 14793: | * |
| 14794: | * @param string $from |
| 14795: | * @param string $to |
| 14796: | * @return bool |
| 14797: | * @static |
| 14798: | */ |
| 14799: | public static function copy($from, $to) |
| 14800: | { |
| 14801: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14802: | return $instance->copy($from, $to); |
| 14803: | } |
| 14804: | /** |
| 14805: | * Move a file to a new location. |
| 14806: | * |
| 14807: | * @param string $from |
| 14808: | * @param string $to |
| 14809: | * @return bool |
| 14810: | * @static |
| 14811: | */ |
| 14812: | public static function move($from, $to) |
| 14813: | { |
| 14814: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14815: | return $instance->move($from, $to); |
| 14816: | } |
| 14817: | /** |
| 14818: | * Get the file size of a given file. |
| 14819: | * |
| 14820: | * @param string $path |
| 14821: | * @return int |
| 14822: | * @static |
| 14823: | */ |
| 14824: | public static function size($path) |
| 14825: | { |
| 14826: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14827: | return $instance->size($path); |
| 14828: | } |
| 14829: | /** |
| 14830: | * Get the mime-type of a given file. |
| 14831: | * |
| 14832: | * @param string $path |
| 14833: | * @return string|false |
| 14834: | * @static |
| 14835: | */ |
| 14836: | public static function mimeType($path) |
| 14837: | { |
| 14838: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14839: | return $instance->mimeType($path); |
| 14840: | } |
| 14841: | /** |
| 14842: | * Get the file's last modification time. |
| 14843: | * |
| 14844: | * @param string $path |
| 14845: | * @return int |
| 14846: | * @static |
| 14847: | */ |
| 14848: | public static function lastModified($path) |
| 14849: | { |
| 14850: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14851: | return $instance->lastModified($path); |
| 14852: | } |
| 14853: | /** |
| 14854: | * Get a resource to read the file. |
| 14855: | * |
| 14856: | * @param string $path |
| 14857: | * @return resource|null The path resource or null on failure. |
| 14858: | * @static |
| 14859: | */ |
| 14860: | public static function readStream($path) |
| 14861: | { |
| 14862: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14863: | return $instance->readStream($path); |
| 14864: | } |
| 14865: | /** |
| 14866: | * Write a new file using a stream. |
| 14867: | * |
| 14868: | * @param string $path |
| 14869: | * @param resource $resource |
| 14870: | * @param array $options |
| 14871: | * @return bool |
| 14872: | * @static |
| 14873: | */ |
| 14874: | public static function writeStream($path, $resource, $options = []) |
| 14875: | { |
| 14876: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14877: | return $instance->writeStream($path, $resource, $options); |
| 14878: | } |
| 14879: | /** |
| 14880: | * Get the URL for the file at the given path. |
| 14881: | * |
| 14882: | * @param string $path |
| 14883: | * @return string |
| 14884: | * @throws \RuntimeException |
| 14885: | * @static |
| 14886: | */ |
| 14887: | public static function url($path) |
| 14888: | { |
| 14889: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14890: | return $instance->url($path); |
| 14891: | } |
| 14892: | /** |
| 14893: | * Get a temporary URL for the file at the given path. |
| 14894: | * |
| 14895: | * @param string $path |
| 14896: | * @param \DateTimeInterface $expiration |
| 14897: | * @param array $options |
| 14898: | * @return string |
| 14899: | * @throws \RuntimeException |
| 14900: | * @static |
| 14901: | */ |
| 14902: | public static function temporaryUrl($path, $expiration, $options = []) |
| 14903: | { |
| 14904: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14905: | return $instance->temporaryUrl($path, $expiration, $options); |
| 14906: | } |
| 14907: | /** |
| 14908: | * Get an array of all files in a directory. |
| 14909: | * |
| 14910: | * @param string|null $directory |
| 14911: | * @param bool $recursive |
| 14912: | * @return array |
| 14913: | * @static |
| 14914: | */ |
| 14915: | public static function files($directory = null, $recursive = false) |
| 14916: | { |
| 14917: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14918: | return $instance->files($directory, $recursive); |
| 14919: | } |
| 14920: | /** |
| 14921: | * Get all of the files from the given directory (recursive). |
| 14922: | * |
| 14923: | * @param string|null $directory |
| 14924: | * @return array |
| 14925: | * @static |
| 14926: | */ |
| 14927: | public static function allFiles($directory = null) |
| 14928: | { |
| 14929: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14930: | return $instance->allFiles($directory); |
| 14931: | } |
| 14932: | /** |
| 14933: | * Get all of the directories within a given directory. |
| 14934: | * |
| 14935: | * @param string|null $directory |
| 14936: | * @param bool $recursive |
| 14937: | * @return array |
| 14938: | * @static |
| 14939: | */ |
| 14940: | public static function directories($directory = null, $recursive = false) |
| 14941: | { |
| 14942: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14943: | return $instance->directories($directory, $recursive); |
| 14944: | } |
| 14945: | /** |
| 14946: | * Get all the directories within a given directory (recursive). |
| 14947: | * |
| 14948: | * @param string|null $directory |
| 14949: | * @return array |
| 14950: | * @static |
| 14951: | */ |
| 14952: | public static function allDirectories($directory = null) |
| 14953: | { |
| 14954: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14955: | return $instance->allDirectories($directory); |
| 14956: | } |
| 14957: | /** |
| 14958: | * Create a directory. |
| 14959: | * |
| 14960: | * @param string $path |
| 14961: | * @return bool |
| 14962: | * @static |
| 14963: | */ |
| 14964: | public static function makeDirectory($path) |
| 14965: | { |
| 14966: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14967: | return $instance->makeDirectory($path); |
| 14968: | } |
| 14969: | /** |
| 14970: | * Recursively delete a directory. |
| 14971: | * |
| 14972: | * @param string $directory |
| 14973: | * @return bool |
| 14974: | * @static |
| 14975: | */ |
| 14976: | public static function deleteDirectory($directory) |
| 14977: | { |
| 14978: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14979: | return $instance->deleteDirectory($directory); |
| 14980: | } |
| 14981: | /** |
| 14982: | * Get the Flysystem driver. |
| 14983: | * |
| 14984: | * @return \League\Flysystem\FilesystemOperator |
| 14985: | * @static |
| 14986: | */ |
| 14987: | public static function getDriver() |
| 14988: | { |
| 14989: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 14990: | return $instance->getDriver(); |
| 14991: | } |
| 14992: | /** |
| 14993: | * Get the Flysystem adapter. |
| 14994: | * |
| 14995: | * @return \League\Flysystem\FilesystemAdapter |
| 14996: | * @static |
| 14997: | */ |
| 14998: | public static function getAdapter() |
| 14999: | { |
| 15000: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 15001: | return $instance->getAdapter(); |
| 15002: | } |
| 15003: | /** |
| 15004: | * Get the configuration values. |
| 15005: | * |
| 15006: | * @return array |
| 15007: | * @static |
| 15008: | */ |
| 15009: | public static function getConfig() |
| 15010: | { |
| 15011: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 15012: | return $instance->getConfig(); |
| 15013: | } |
| 15014: | /** |
| 15015: | * Define a custom temporary URL builder callback. |
| 15016: | * |
| 15017: | * @param \Closure $callback |
| 15018: | * @return void |
| 15019: | * @static |
| 15020: | */ |
| 15021: | public static function buildTemporaryUrlsUsing($callback) |
| 15022: | { |
| 15023: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 15024: | $instance->buildTemporaryUrlsUsing($callback); |
| 15025: | } |
| 15026: | /** |
| 15027: | * Register a custom macro. |
| 15028: | * |
| 15029: | * @param string $name |
| 15030: | * @param object|callable $macro |
| 15031: | * @return void |
| 15032: | * @static |
| 15033: | */ |
| 15034: | public static function macro($name, $macro) |
| 15035: | { |
| 15036: | \Illuminate\Filesystem\FilesystemAdapter::macro($name, $macro); |
| 15037: | } |
| 15038: | /** |
| 15039: | * Mix another object into the class. |
| 15040: | * |
| 15041: | * @param object $mixin |
| 15042: | * @param bool $replace |
| 15043: | * @return void |
| 15044: | * @throws \ReflectionException |
| 15045: | * @static |
| 15046: | */ |
| 15047: | public static function mixin($mixin, $replace = true) |
| 15048: | { |
| 15049: | \Illuminate\Filesystem\FilesystemAdapter::mixin($mixin, $replace); |
| 15050: | } |
| 15051: | /** |
| 15052: | * Checks if macro is registered. |
| 15053: | * |
| 15054: | * @param string $name |
| 15055: | * @return bool |
| 15056: | * @static |
| 15057: | */ |
| 15058: | public static function hasMacro($name) |
| 15059: | { |
| 15060: | return \Illuminate\Filesystem\FilesystemAdapter::hasMacro($name); |
| 15061: | } |
| 15062: | /** |
| 15063: | * Flush the existing macros. |
| 15064: | * |
| 15065: | * @return void |
| 15066: | * @static |
| 15067: | */ |
| 15068: | public static function flushMacros() |
| 15069: | { |
| 15070: | \Illuminate\Filesystem\FilesystemAdapter::flushMacros(); |
| 15071: | } |
| 15072: | /** |
| 15073: | * Dynamically handle calls to the class. |
| 15074: | * |
| 15075: | * @param string $method |
| 15076: | * @param array $parameters |
| 15077: | * @return mixed |
| 15078: | * @throws \BadMethodCallException |
| 15079: | * @static |
| 15080: | */ |
| 15081: | public static function macroCall($method, $parameters) |
| 15082: | { |
| 15083: | /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */ |
| 15084: | return $instance->macroCall($method, $parameters); |
| 15085: | } |
| 15086: | |
| 15087: | } |
| 15088: | /** |
| 15089: | * |
| 15090: | * |
| 15091: | * @see \Illuminate\Routing\UrlGenerator |
| 15092: | */ |
| 15093: | class URL { |
| 15094: | /** |
| 15095: | * Get the full URL for the current request. |
| 15096: | * |
| 15097: | * @return string |
| 15098: | * @static |
| 15099: | */ |
| 15100: | public static function full() |
| 15101: | { |
| 15102: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15103: | return $instance->full(); |
| 15104: | } |
| 15105: | /** |
| 15106: | * Get the current URL for the request. |
| 15107: | * |
| 15108: | * @return string |
| 15109: | * @static |
| 15110: | */ |
| 15111: | public static function current() |
| 15112: | { |
| 15113: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15114: | return $instance->current(); |
| 15115: | } |
| 15116: | /** |
| 15117: | * Get the URL for the previous request. |
| 15118: | * |
| 15119: | * @param mixed $fallback |
| 15120: | * @return string |
| 15121: | * @static |
| 15122: | */ |
| 15123: | public static function previous($fallback = false) |
| 15124: | { |
| 15125: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15126: | return $instance->previous($fallback); |
| 15127: | } |
| 15128: | /** |
| 15129: | * Get the previous path info for the request. |
| 15130: | * |
| 15131: | * @param mixed $fallback |
| 15132: | * @return string |
| 15133: | * @static |
| 15134: | */ |
| 15135: | public static function previousPath($fallback = false) |
| 15136: | { |
| 15137: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15138: | return $instance->previousPath($fallback); |
| 15139: | } |
| 15140: | /** |
| 15141: | * Generate an absolute URL to the given path. |
| 15142: | * |
| 15143: | * @param string $path |
| 15144: | * @param mixed $extra |
| 15145: | * @param bool|null $secure |
| 15146: | * @return string |
| 15147: | * @static |
| 15148: | */ |
| 15149: | public static function to($path, $extra = [], $secure = null) |
| 15150: | { |
| 15151: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15152: | return $instance->to($path, $extra, $secure); |
| 15153: | } |
| 15154: | /** |
| 15155: | * Generate a secure, absolute URL to the given path. |
| 15156: | * |
| 15157: | * @param string $path |
| 15158: | * @param array $parameters |
| 15159: | * @return string |
| 15160: | * @static |
| 15161: | */ |
| 15162: | public static function secure($path, $parameters = []) |
| 15163: | { |
| 15164: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15165: | return $instance->secure($path, $parameters); |
| 15166: | } |
| 15167: | /** |
| 15168: | * Generate the URL to an application asset. |
| 15169: | * |
| 15170: | * @param string $path |
| 15171: | * @param bool|null $secure |
| 15172: | * @return string |
| 15173: | * @static |
| 15174: | */ |
| 15175: | public static function asset($path, $secure = null) |
| 15176: | { |
| 15177: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15178: | return $instance->asset($path, $secure); |
| 15179: | } |
| 15180: | /** |
| 15181: | * Generate the URL to a secure asset. |
| 15182: | * |
| 15183: | * @param string $path |
| 15184: | * @return string |
| 15185: | * @static |
| 15186: | */ |
| 15187: | public static function secureAsset($path) |
| 15188: | { |
| 15189: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15190: | return $instance->secureAsset($path); |
| 15191: | } |
| 15192: | /** |
| 15193: | * Generate the URL to an asset from a custom root domain such as CDN, etc. |
| 15194: | * |
| 15195: | * @param string $root |
| 15196: | * @param string $path |
| 15197: | * @param bool|null $secure |
| 15198: | * @return string |
| 15199: | * @static |
| 15200: | */ |
| 15201: | public static function assetFrom($root, $path, $secure = null) |
| 15202: | { |
| 15203: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15204: | return $instance->assetFrom($root, $path, $secure); |
| 15205: | } |
| 15206: | /** |
| 15207: | * Get the default scheme for a raw URL. |
| 15208: | * |
| 15209: | * @param bool|null $secure |
| 15210: | * @return string |
| 15211: | * @static |
| 15212: | */ |
| 15213: | public static function formatScheme($secure = null) |
| 15214: | { |
| 15215: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15216: | return $instance->formatScheme($secure); |
| 15217: | } |
| 15218: | /** |
| 15219: | * Create a signed route URL for a named route. |
| 15220: | * |
| 15221: | * @param string $name |
| 15222: | * @param mixed $parameters |
| 15223: | * @param \DateTimeInterface|\DateInterval|int|null $expiration |
| 15224: | * @param bool $absolute |
| 15225: | * @return string |
| 15226: | * @throws \InvalidArgumentException |
| 15227: | * @static |
| 15228: | */ |
| 15229: | public static function signedRoute($name, $parameters = [], $expiration = null, $absolute = true) |
| 15230: | { |
| 15231: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15232: | return $instance->signedRoute($name, $parameters, $expiration, $absolute); |
| 15233: | } |
| 15234: | /** |
| 15235: | * Create a temporary signed route URL for a named route. |
| 15236: | * |
| 15237: | * @param string $name |
| 15238: | * @param \DateTimeInterface|\DateInterval|int $expiration |
| 15239: | * @param array $parameters |
| 15240: | * @param bool $absolute |
| 15241: | * @return string |
| 15242: | * @static |
| 15243: | */ |
| 15244: | public static function temporarySignedRoute($name, $expiration, $parameters = [], $absolute = true) |
| 15245: | { |
| 15246: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15247: | return $instance->temporarySignedRoute($name, $expiration, $parameters, $absolute); |
| 15248: | } |
| 15249: | /** |
| 15250: | * Determine if the given request has a valid signature. |
| 15251: | * |
| 15252: | * @param \Illuminate\Http\Request $request |
| 15253: | * @param bool $absolute |
| 15254: | * @param array $ignoreQuery |
| 15255: | * @return bool |
| 15256: | * @static |
| 15257: | */ |
| 15258: | public static function hasValidSignature($request, $absolute = true, $ignoreQuery = []) |
| 15259: | { |
| 15260: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15261: | return $instance->hasValidSignature($request, $absolute, $ignoreQuery); |
| 15262: | } |
| 15263: | /** |
| 15264: | * Determine if the given request has a valid signature for a relative URL. |
| 15265: | * |
| 15266: | * @param \Illuminate\Http\Request $request |
| 15267: | * @param array $ignoreQuery |
| 15268: | * @return bool |
| 15269: | * @static |
| 15270: | */ |
| 15271: | public static function hasValidRelativeSignature($request, $ignoreQuery = []) |
| 15272: | { |
| 15273: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15274: | return $instance->hasValidRelativeSignature($request, $ignoreQuery); |
| 15275: | } |
| 15276: | /** |
| 15277: | * Determine if the signature from the given request matches the URL. |
| 15278: | * |
| 15279: | * @param \Illuminate\Http\Request $request |
| 15280: | * @param bool $absolute |
| 15281: | * @param array $ignoreQuery |
| 15282: | * @return bool |
| 15283: | * @static |
| 15284: | */ |
| 15285: | public static function hasCorrectSignature($request, $absolute = true, $ignoreQuery = []) |
| 15286: | { |
| 15287: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15288: | return $instance->hasCorrectSignature($request, $absolute, $ignoreQuery); |
| 15289: | } |
| 15290: | /** |
| 15291: | * Determine if the expires timestamp from the given request is not from the past. |
| 15292: | * |
| 15293: | * @param \Illuminate\Http\Request $request |
| 15294: | * @return bool |
| 15295: | * @static |
| 15296: | */ |
| 15297: | public static function signatureHasNotExpired($request) |
| 15298: | { |
| 15299: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15300: | return $instance->signatureHasNotExpired($request); |
| 15301: | } |
| 15302: | /** |
| 15303: | * Get the URL to a named route. |
| 15304: | * |
| 15305: | * @param string $name |
| 15306: | * @param mixed $parameters |
| 15307: | * @param bool $absolute |
| 15308: | * @return string |
| 15309: | * @throws \Symfony\Component\Routing\Exception\RouteNotFoundException |
| 15310: | * @static |
| 15311: | */ |
| 15312: | public static function route($name, $parameters = [], $absolute = true) |
| 15313: | { |
| 15314: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15315: | return $instance->route($name, $parameters, $absolute); |
| 15316: | } |
| 15317: | /** |
| 15318: | * Get the URL for a given route instance. |
| 15319: | * |
| 15320: | * @param \Illuminate\Routing\Route $route |
| 15321: | * @param mixed $parameters |
| 15322: | * @param bool $absolute |
| 15323: | * @return string |
| 15324: | * @throws \Illuminate\Routing\Exceptions\UrlGenerationException |
| 15325: | * @static |
| 15326: | */ |
| 15327: | public static function toRoute($route, $parameters, $absolute) |
| 15328: | { |
| 15329: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15330: | return $instance->toRoute($route, $parameters, $absolute); |
| 15331: | } |
| 15332: | /** |
| 15333: | * Get the URL to a controller action. |
| 15334: | * |
| 15335: | * @param string|array $action |
| 15336: | * @param mixed $parameters |
| 15337: | * @param bool $absolute |
| 15338: | * @return string |
| 15339: | * @throws \InvalidArgumentException |
| 15340: | * @static |
| 15341: | */ |
| 15342: | public static function action($action, $parameters = [], $absolute = true) |
| 15343: | { |
| 15344: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15345: | return $instance->action($action, $parameters, $absolute); |
| 15346: | } |
| 15347: | /** |
| 15348: | * Format the array of URL parameters. |
| 15349: | * |
| 15350: | * @param mixed|array $parameters |
| 15351: | * @return array |
| 15352: | * @static |
| 15353: | */ |
| 15354: | public static function formatParameters($parameters) |
| 15355: | { |
| 15356: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15357: | return $instance->formatParameters($parameters); |
| 15358: | } |
| 15359: | /** |
| 15360: | * Get the base URL for the request. |
| 15361: | * |
| 15362: | * @param string $scheme |
| 15363: | * @param string|null $root |
| 15364: | * @return string |
| 15365: | * @static |
| 15366: | */ |
| 15367: | public static function formatRoot($scheme, $root = null) |
| 15368: | { |
| 15369: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15370: | return $instance->formatRoot($scheme, $root); |
| 15371: | } |
| 15372: | /** |
| 15373: | * Format the given URL segments into a single URL. |
| 15374: | * |
| 15375: | * @param string $root |
| 15376: | * @param string $path |
| 15377: | * @param \Illuminate\Routing\Route|null $route |
| 15378: | * @return string |
| 15379: | * @static |
| 15380: | */ |
| 15381: | public static function format($root, $path, $route = null) |
| 15382: | { |
| 15383: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15384: | return $instance->format($root, $path, $route); |
| 15385: | } |
| 15386: | /** |
| 15387: | * Determine if the given path is a valid URL. |
| 15388: | * |
| 15389: | * @param string $path |
| 15390: | * @return bool |
| 15391: | * @static |
| 15392: | */ |
| 15393: | public static function isValidUrl($path) |
| 15394: | { |
| 15395: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15396: | return $instance->isValidUrl($path); |
| 15397: | } |
| 15398: | /** |
| 15399: | * Set the default named parameters used by the URL generator. |
| 15400: | * |
| 15401: | * @param array $defaults |
| 15402: | * @return void |
| 15403: | * @static |
| 15404: | */ |
| 15405: | public static function defaults($defaults) |
| 15406: | { |
| 15407: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15408: | $instance->defaults($defaults); |
| 15409: | } |
| 15410: | /** |
| 15411: | * Get the default named parameters used by the URL generator. |
| 15412: | * |
| 15413: | * @return array |
| 15414: | * @static |
| 15415: | */ |
| 15416: | public static function getDefaultParameters() |
| 15417: | { |
| 15418: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15419: | return $instance->getDefaultParameters(); |
| 15420: | } |
| 15421: | /** |
| 15422: | * Force the scheme for URLs. |
| 15423: | * |
| 15424: | * @param string|null $scheme |
| 15425: | * @return void |
| 15426: | * @static |
| 15427: | */ |
| 15428: | public static function forceScheme($scheme) |
| 15429: | { |
| 15430: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15431: | $instance->forceScheme($scheme); |
| 15432: | } |
| 15433: | /** |
| 15434: | * Set the forced root URL. |
| 15435: | * |
| 15436: | * @param string|null $root |
| 15437: | * @return void |
| 15438: | * @static |
| 15439: | */ |
| 15440: | public static function forceRootUrl($root) |
| 15441: | { |
| 15442: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15443: | $instance->forceRootUrl($root); |
| 15444: | } |
| 15445: | /** |
| 15446: | * Set a callback to be used to format the host of generated URLs. |
| 15447: | * |
| 15448: | * @param \Closure $callback |
| 15449: | * @return \Illuminate\Routing\UrlGenerator |
| 15450: | * @static |
| 15451: | */ |
| 15452: | public static function formatHostUsing($callback) |
| 15453: | { |
| 15454: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15455: | return $instance->formatHostUsing($callback); |
| 15456: | } |
| 15457: | /** |
| 15458: | * Set a callback to be used to format the path of generated URLs. |
| 15459: | * |
| 15460: | * @param \Closure $callback |
| 15461: | * @return \Illuminate\Routing\UrlGenerator |
| 15462: | * @static |
| 15463: | */ |
| 15464: | public static function formatPathUsing($callback) |
| 15465: | { |
| 15466: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15467: | return $instance->formatPathUsing($callback); |
| 15468: | } |
| 15469: | /** |
| 15470: | * Get the path formatter being used by the URL generator. |
| 15471: | * |
| 15472: | * @return \Closure |
| 15473: | * @static |
| 15474: | */ |
| 15475: | public static function pathFormatter() |
| 15476: | { |
| 15477: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15478: | return $instance->pathFormatter(); |
| 15479: | } |
| 15480: | /** |
| 15481: | * Get the request instance. |
| 15482: | * |
| 15483: | * @return \Illuminate\Http\Request |
| 15484: | * @static |
| 15485: | */ |
| 15486: | public static function getRequest() |
| 15487: | { |
| 15488: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15489: | return $instance->getRequest(); |
| 15490: | } |
| 15491: | /** |
| 15492: | * Set the current request instance. |
| 15493: | * |
| 15494: | * @param \Illuminate\Http\Request $request |
| 15495: | * @return void |
| 15496: | * @static |
| 15497: | */ |
| 15498: | public static function setRequest($request) |
| 15499: | { |
| 15500: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15501: | $instance->setRequest($request); |
| 15502: | } |
| 15503: | /** |
| 15504: | * Set the route collection. |
| 15505: | * |
| 15506: | * @param \Illuminate\Routing\RouteCollectionInterface $routes |
| 15507: | * @return \Illuminate\Routing\UrlGenerator |
| 15508: | * @static |
| 15509: | */ |
| 15510: | public static function setRoutes($routes) |
| 15511: | { |
| 15512: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15513: | return $instance->setRoutes($routes); |
| 15514: | } |
| 15515: | /** |
| 15516: | * Set the session resolver for the generator. |
| 15517: | * |
| 15518: | * @param callable $sessionResolver |
| 15519: | * @return \Illuminate\Routing\UrlGenerator |
| 15520: | * @static |
| 15521: | */ |
| 15522: | public static function setSessionResolver($sessionResolver) |
| 15523: | { |
| 15524: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15525: | return $instance->setSessionResolver($sessionResolver); |
| 15526: | } |
| 15527: | /** |
| 15528: | * Set the encryption key resolver. |
| 15529: | * |
| 15530: | * @param callable $keyResolver |
| 15531: | * @return \Illuminate\Routing\UrlGenerator |
| 15532: | * @static |
| 15533: | */ |
| 15534: | public static function setKeyResolver($keyResolver) |
| 15535: | { |
| 15536: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15537: | return $instance->setKeyResolver($keyResolver); |
| 15538: | } |
| 15539: | /** |
| 15540: | * Get the root controller namespace. |
| 15541: | * |
| 15542: | * @return string |
| 15543: | * @static |
| 15544: | */ |
| 15545: | public static function getRootControllerNamespace() |
| 15546: | { |
| 15547: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15548: | return $instance->getRootControllerNamespace(); |
| 15549: | } |
| 15550: | /** |
| 15551: | * Set the root controller namespace. |
| 15552: | * |
| 15553: | * @param string $rootNamespace |
| 15554: | * @return \Illuminate\Routing\UrlGenerator |
| 15555: | * @static |
| 15556: | */ |
| 15557: | public static function setRootControllerNamespace($rootNamespace) |
| 15558: | { |
| 15559: | /** @var \Illuminate\Routing\UrlGenerator $instance */ |
| 15560: | return $instance->setRootControllerNamespace($rootNamespace); |
| 15561: | } |
| 15562: | /** |
| 15563: | * Register a custom macro. |
| 15564: | * |
| 15565: | * @param string $name |
| 15566: | * @param object|callable $macro |
| 15567: | * @return void |
| 15568: | * @static |
| 15569: | */ |
| 15570: | public static function macro($name, $macro) |
| 15571: | { |
| 15572: | \Illuminate\Routing\UrlGenerator::macro($name, $macro); |
| 15573: | } |
| 15574: | /** |
| 15575: | * Mix another object into the class. |
| 15576: | * |
| 15577: | * @param object $mixin |
| 15578: | * @param bool $replace |
| 15579: | * @return void |
| 15580: | * @throws \ReflectionException |
| 15581: | * @static |
| 15582: | */ |
| 15583: | public static function mixin($mixin, $replace = true) |
| 15584: | { |
| 15585: | \Illuminate\Routing\UrlGenerator::mixin($mixin, $replace); |
| 15586: | } |
| 15587: | /** |
| 15588: | * Checks if macro is registered. |
| 15589: | * |
| 15590: | * @param string $name |
| 15591: | * @return bool |
| 15592: | * @static |
| 15593: | */ |
| 15594: | public static function hasMacro($name) |
| 15595: | { |
| 15596: | return \Illuminate\Routing\UrlGenerator::hasMacro($name); |
| 15597: | } |
| 15598: | /** |
| 15599: | * Flush the existing macros. |
| 15600: | * |
| 15601: | * @return void |
| 15602: | * @static |
| 15603: | */ |
| 15604: | public static function flushMacros() |
| 15605: | { |
| 15606: | \Illuminate\Routing\UrlGenerator::flushMacros(); |
| 15607: | } |
| 15608: | |
| 15609: | } |
| 15610: | /** |
| 15611: | * |
| 15612: | * |
| 15613: | * @see \Illuminate\Validation\Factory |
| 15614: | */ |
| 15615: | class Validator { |
| 15616: | /** |
| 15617: | * Create a new Validator instance. |
| 15618: | * |
| 15619: | * @param array $data |
| 15620: | * @param array $rules |
| 15621: | * @param array $messages |
| 15622: | * @param array $customAttributes |
| 15623: | * @return \Illuminate\Validation\Validator |
| 15624: | * @static |
| 15625: | */ |
| 15626: | public static function make($data, $rules, $messages = [], $customAttributes = []) |
| 15627: | { |
| 15628: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15629: | return $instance->make($data, $rules, $messages, $customAttributes); |
| 15630: | } |
| 15631: | /** |
| 15632: | * Validate the given data against the provided rules. |
| 15633: | * |
| 15634: | * @param array $data |
| 15635: | * @param array $rules |
| 15636: | * @param array $messages |
| 15637: | * @param array $customAttributes |
| 15638: | * @return array |
| 15639: | * @throws \Illuminate\Validation\ValidationException |
| 15640: | * @static |
| 15641: | */ |
| 15642: | public static function validate($data, $rules, $messages = [], $customAttributes = []) |
| 15643: | { |
| 15644: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15645: | return $instance->validate($data, $rules, $messages, $customAttributes); |
| 15646: | } |
| 15647: | /** |
| 15648: | * Register a custom validator extension. |
| 15649: | * |
| 15650: | * @param string $rule |
| 15651: | * @param \Closure|string $extension |
| 15652: | * @param string|null $message |
| 15653: | * @return void |
| 15654: | * @static |
| 15655: | */ |
| 15656: | public static function extend($rule, $extension, $message = null) |
| 15657: | { |
| 15658: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15659: | $instance->extend($rule, $extension, $message); |
| 15660: | } |
| 15661: | /** |
| 15662: | * Register a custom implicit validator extension. |
| 15663: | * |
| 15664: | * @param string $rule |
| 15665: | * @param \Closure|string $extension |
| 15666: | * @param string|null $message |
| 15667: | * @return void |
| 15668: | * @static |
| 15669: | */ |
| 15670: | public static function extendImplicit($rule, $extension, $message = null) |
| 15671: | { |
| 15672: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15673: | $instance->extendImplicit($rule, $extension, $message); |
| 15674: | } |
| 15675: | /** |
| 15676: | * Register a custom dependent validator extension. |
| 15677: | * |
| 15678: | * @param string $rule |
| 15679: | * @param \Closure|string $extension |
| 15680: | * @param string|null $message |
| 15681: | * @return void |
| 15682: | * @static |
| 15683: | */ |
| 15684: | public static function extendDependent($rule, $extension, $message = null) |
| 15685: | { |
| 15686: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15687: | $instance->extendDependent($rule, $extension, $message); |
| 15688: | } |
| 15689: | /** |
| 15690: | * Register a custom validator message replacer. |
| 15691: | * |
| 15692: | * @param string $rule |
| 15693: | * @param \Closure|string $replacer |
| 15694: | * @return void |
| 15695: | * @static |
| 15696: | */ |
| 15697: | public static function replacer($rule, $replacer) |
| 15698: | { |
| 15699: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15700: | $instance->replacer($rule, $replacer); |
| 15701: | } |
| 15702: | /** |
| 15703: | * Indicate that unvalidated array keys should be included in validated data when the parent array is validated. |
| 15704: | * |
| 15705: | * @return void |
| 15706: | * @static |
| 15707: | */ |
| 15708: | public static function includeUnvalidatedArrayKeys() |
| 15709: | { |
| 15710: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15711: | $instance->includeUnvalidatedArrayKeys(); |
| 15712: | } |
| 15713: | /** |
| 15714: | * Indicate that unvalidated array keys should be excluded from the validated data, even if the parent array was validated. |
| 15715: | * |
| 15716: | * @return void |
| 15717: | * @static |
| 15718: | */ |
| 15719: | public static function excludeUnvalidatedArrayKeys() |
| 15720: | { |
| 15721: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15722: | $instance->excludeUnvalidatedArrayKeys(); |
| 15723: | } |
| 15724: | /** |
| 15725: | * Set the Validator instance resolver. |
| 15726: | * |
| 15727: | * @param \Closure $resolver |
| 15728: | * @return void |
| 15729: | * @static |
| 15730: | */ |
| 15731: | public static function resolver($resolver) |
| 15732: | { |
| 15733: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15734: | $instance->resolver($resolver); |
| 15735: | } |
| 15736: | /** |
| 15737: | * Get the Translator implementation. |
| 15738: | * |
| 15739: | * @return \Illuminate\Contracts\Translation\Translator |
| 15740: | * @static |
| 15741: | */ |
| 15742: | public static function getTranslator() |
| 15743: | { |
| 15744: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15745: | return $instance->getTranslator(); |
| 15746: | } |
| 15747: | /** |
| 15748: | * Get the Presence Verifier implementation. |
| 15749: | * |
| 15750: | * @return \Illuminate\Validation\PresenceVerifierInterface |
| 15751: | * @static |
| 15752: | */ |
| 15753: | public static function getPresenceVerifier() |
| 15754: | { |
| 15755: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15756: | return $instance->getPresenceVerifier(); |
| 15757: | } |
| 15758: | /** |
| 15759: | * Set the Presence Verifier implementation. |
| 15760: | * |
| 15761: | * @param \Illuminate\Validation\PresenceVerifierInterface $presenceVerifier |
| 15762: | * @return void |
| 15763: | * @static |
| 15764: | */ |
| 15765: | public static function setPresenceVerifier($presenceVerifier) |
| 15766: | { |
| 15767: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15768: | $instance->setPresenceVerifier($presenceVerifier); |
| 15769: | } |
| 15770: | /** |
| 15771: | * Get the container instance used by the validation factory. |
| 15772: | * |
| 15773: | * @return \Illuminate\Contracts\Container\Container|null |
| 15774: | * @static |
| 15775: | */ |
| 15776: | public static function getContainer() |
| 15777: | { |
| 15778: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15779: | return $instance->getContainer(); |
| 15780: | } |
| 15781: | /** |
| 15782: | * Set the container instance used by the validation factory. |
| 15783: | * |
| 15784: | * @param \Illuminate\Contracts\Container\Container $container |
| 15785: | * @return \Illuminate\Validation\Factory |
| 15786: | * @static |
| 15787: | */ |
| 15788: | public static function setContainer($container) |
| 15789: | { |
| 15790: | /** @var \Illuminate\Validation\Factory $instance */ |
| 15791: | return $instance->setContainer($container); |
| 15792: | } |
| 15793: | |
| 15794: | } |
| 15795: | /** |
| 15796: | * |
| 15797: | * |
| 15798: | * @see \Illuminate\View\Factory |
| 15799: | */ |
| 15800: | class View { |
| 15801: | /** |
| 15802: | * Get the evaluated view contents for the given view. |
| 15803: | * |
| 15804: | * @param string $path |
| 15805: | * @param \Illuminate\Contracts\Support\Arrayable|array $data |
| 15806: | * @param array $mergeData |
| 15807: | * @return \Illuminate\Contracts\View\View |
| 15808: | * @static |
| 15809: | */ |
| 15810: | public static function file($path, $data = [], $mergeData = []) |
| 15811: | { |
| 15812: | /** @var \Illuminate\View\Factory $instance */ |
| 15813: | return $instance->file($path, $data, $mergeData); |
| 15814: | } |
| 15815: | /** |
| 15816: | * Get the evaluated view contents for the given view. |
| 15817: | * |
| 15818: | * @param string $view |
| 15819: | * @param \Illuminate\Contracts\Support\Arrayable|array $data |
| 15820: | * @param array $mergeData |
| 15821: | * @return \Illuminate\Contracts\View\View |
| 15822: | * @static |
| 15823: | */ |
| 15824: | public static function make($view, $data = [], $mergeData = []) |
| 15825: | { |
| 15826: | /** @var \Illuminate\View\Factory $instance */ |
| 15827: | return $instance->make($view, $data, $mergeData); |
| 15828: | } |
| 15829: | /** |
| 15830: | * Get the first view that actually exists from the given list. |
| 15831: | * |
| 15832: | * @param array $views |
| 15833: | * @param \Illuminate\Contracts\Support\Arrayable|array $data |
| 15834: | * @param array $mergeData |
| 15835: | * @return \Illuminate\Contracts\View\View |
| 15836: | * @throws \InvalidArgumentException |
| 15837: | * @static |
| 15838: | */ |
| 15839: | public static function first($views, $data = [], $mergeData = []) |
| 15840: | { |
| 15841: | /** @var \Illuminate\View\Factory $instance */ |
| 15842: | return $instance->first($views, $data, $mergeData); |
| 15843: | } |
| 15844: | /** |
| 15845: | * Get the rendered content of the view based on a given condition. |
| 15846: | * |
| 15847: | * @param bool $condition |
| 15848: | * @param string $view |
| 15849: | * @param \Illuminate\Contracts\Support\Arrayable|array $data |
| 15850: | * @param array $mergeData |
| 15851: | * @return string |
| 15852: | * @static |
| 15853: | */ |
| 15854: | public static function renderWhen($condition, $view, $data = [], $mergeData = []) |
| 15855: | { |
| 15856: | /** @var \Illuminate\View\Factory $instance */ |
| 15857: | return $instance->renderWhen($condition, $view, $data, $mergeData); |
| 15858: | } |
| 15859: | /** |
| 15860: | * Get the rendered content of the view based on the negation of a given condition. |
| 15861: | * |
| 15862: | * @param bool $condition |
| 15863: | * @param string $view |
| 15864: | * @param \Illuminate\Contracts\Support\Arrayable|array $data |
| 15865: | * @param array $mergeData |
| 15866: | * @return string |
| 15867: | * @static |
| 15868: | */ |
| 15869: | public static function renderUnless($condition, $view, $data = [], $mergeData = []) |
| 15870: | { |
| 15871: | /** @var \Illuminate\View\Factory $instance */ |
| 15872: | return $instance->renderUnless($condition, $view, $data, $mergeData); |
| 15873: | } |
| 15874: | /** |
| 15875: | * Get the rendered contents of a partial from a loop. |
| 15876: | * |
| 15877: | * @param string $view |
| 15878: | * @param array $data |
| 15879: | * @param string $iterator |
| 15880: | * @param string $empty |
| 15881: | * @return string |
| 15882: | * @static |
| 15883: | */ |
| 15884: | public static function renderEach($view, $data, $iterator, $empty = 'raw|') |
| 15885: | { |
| 15886: | /** @var \Illuminate\View\Factory $instance */ |
| 15887: | return $instance->renderEach($view, $data, $iterator, $empty); |
| 15888: | } |
| 15889: | /** |
| 15890: | * Determine if a given view exists. |
| 15891: | * |
| 15892: | * @param string $view |
| 15893: | * @return bool |
| 15894: | * @static |
| 15895: | */ |
| 15896: | public static function exists($view) |
| 15897: | { |
| 15898: | /** @var \Illuminate\View\Factory $instance */ |
| 15899: | return $instance->exists($view); |
| 15900: | } |
| 15901: | /** |
| 15902: | * Get the appropriate view engine for the given path. |
| 15903: | * |
| 15904: | * @param string $path |
| 15905: | * @return \Illuminate\Contracts\View\Engine |
| 15906: | * @throws \InvalidArgumentException |
| 15907: | * @static |
| 15908: | */ |
| 15909: | public static function getEngineFromPath($path) |
| 15910: | { |
| 15911: | /** @var \Illuminate\View\Factory $instance */ |
| 15912: | return $instance->getEngineFromPath($path); |
| 15913: | } |
| 15914: | /** |
| 15915: | * Add a piece of shared data to the environment. |
| 15916: | * |
| 15917: | * @param array|string $key |
| 15918: | * @param mixed|null $value |
| 15919: | * @return mixed |
| 15920: | * @static |
| 15921: | */ |
| 15922: | public static function share($key, $value = null) |
| 15923: | { |
| 15924: | /** @var \Illuminate\View\Factory $instance */ |
| 15925: | return $instance->share($key, $value); |
| 15926: | } |
| 15927: | /** |
| 15928: | * Increment the rendering counter. |
| 15929: | * |
| 15930: | * @return void |
| 15931: | * @static |
| 15932: | */ |
| 15933: | public static function incrementRender() |
| 15934: | { |
| 15935: | /** @var \Illuminate\View\Factory $instance */ |
| 15936: | $instance->incrementRender(); |
| 15937: | } |
| 15938: | /** |
| 15939: | * Decrement the rendering counter. |
| 15940: | * |
| 15941: | * @return void |
| 15942: | * @static |
| 15943: | */ |
| 15944: | public static function decrementRender() |
| 15945: | { |
| 15946: | /** @var \Illuminate\View\Factory $instance */ |
| 15947: | $instance->decrementRender(); |
| 15948: | } |
| 15949: | /** |
| 15950: | * Check if there are no active render operations. |
| 15951: | * |
| 15952: | * @return bool |
| 15953: | * @static |
| 15954: | */ |
| 15955: | public static function doneRendering() |
| 15956: | { |
| 15957: | /** @var \Illuminate\View\Factory $instance */ |
| 15958: | return $instance->doneRendering(); |
| 15959: | } |
| 15960: | /** |
| 15961: | * Determine if the given once token has been rendered. |
| 15962: | * |
| 15963: | * @param string $id |
| 15964: | * @return bool |
| 15965: | * @static |
| 15966: | */ |
| 15967: | public static function hasRenderedOnce($id) |
| 15968: | { |
| 15969: | /** @var \Illuminate\View\Factory $instance */ |
| 15970: | return $instance->hasRenderedOnce($id); |
| 15971: | } |
| 15972: | /** |
| 15973: | * Mark the given once token as having been rendered. |
| 15974: | * |
| 15975: | * @param string $id |
| 15976: | * @return void |
| 15977: | * @static |
| 15978: | */ |
| 15979: | public static function markAsRenderedOnce($id) |
| 15980: | { |
| 15981: | /** @var \Illuminate\View\Factory $instance */ |
| 15982: | $instance->markAsRenderedOnce($id); |
| 15983: | } |
| 15984: | /** |
| 15985: | * Add a location to the array of view locations. |
| 15986: | * |
| 15987: | * @param string $location |
| 15988: | * @return void |
| 15989: | * @static |
| 15990: | */ |
| 15991: | public static function addLocation($location) |
| 15992: | { |
| 15993: | /** @var \Illuminate\View\Factory $instance */ |
| 15994: | $instance->addLocation($location); |
| 15995: | } |
| 15996: | /** |
| 15997: | * Add a new namespace to the loader. |
| 15998: | * |
| 15999: | * @param string $namespace |
| 16000: | * @param string|array $hints |
| 16001: | * @return \Illuminate\View\Factory |
| 16002: | * @static |
| 16003: | */ |
| 16004: | public static function addNamespace($namespace, $hints) |
| 16005: | { |
| 16006: | /** @var \Illuminate\View\Factory $instance */ |
| 16007: | return $instance->addNamespace($namespace, $hints); |
| 16008: | } |
| 16009: | /** |
| 16010: | * Prepend a new namespace to the loader. |
| 16011: | * |
| 16012: | * @param string $namespace |
| 16013: | * @param string|array $hints |
| 16014: | * @return \Illuminate\View\Factory |
| 16015: | * @static |
| 16016: | */ |
| 16017: | public static function prependNamespace($namespace, $hints) |
| 16018: | { |
| 16019: | /** @var \Illuminate\View\Factory $instance */ |
| 16020: | return $instance->prependNamespace($namespace, $hints); |
| 16021: | } |
| 16022: | /** |
| 16023: | * Replace the namespace hints for the given namespace. |
| 16024: | * |
| 16025: | * @param string $namespace |
| 16026: | * @param string|array $hints |
| 16027: | * @return \Illuminate\View\Factory |
| 16028: | * @static |
| 16029: | */ |
| 16030: | public static function replaceNamespace($namespace, $hints) |
| 16031: | { |
| 16032: | /** @var \Illuminate\View\Factory $instance */ |
| 16033: | return $instance->replaceNamespace($namespace, $hints); |
| 16034: | } |
| 16035: | /** |
| 16036: | * Register a valid view extension and its engine. |
| 16037: | * |
| 16038: | * @param string $extension |
| 16039: | * @param string $engine |
| 16040: | * @param \Closure|null $resolver |
| 16041: | * @return void |
| 16042: | * @static |
| 16043: | */ |
| 16044: | public static function addExtension($extension, $engine, $resolver = null) |
| 16045: | { |
| 16046: | /** @var \Illuminate\View\Factory $instance */ |
| 16047: | $instance->addExtension($extension, $engine, $resolver); |
| 16048: | } |
| 16049: | /** |
| 16050: | * Flush all of the factory state like sections and stacks. |
| 16051: | * |
| 16052: | * @return void |
| 16053: | * @static |
| 16054: | */ |
| 16055: | public static function flushState() |
| 16056: | { |
| 16057: | /** @var \Illuminate\View\Factory $instance */ |
| 16058: | $instance->flushState(); |
| 16059: | } |
| 16060: | /** |
| 16061: | * Flush all of the section contents if done rendering. |
| 16062: | * |
| 16063: | * @return void |
| 16064: | * @static |
| 16065: | */ |
| 16066: | public static function flushStateIfDoneRendering() |
| 16067: | { |
| 16068: | /** @var \Illuminate\View\Factory $instance */ |
| 16069: | $instance->flushStateIfDoneRendering(); |
| 16070: | } |
| 16071: | /** |
| 16072: | * Get the extension to engine bindings. |
| 16073: | * |
| 16074: | * @return array |
| 16075: | * @static |
| 16076: | */ |
| 16077: | public static function getExtensions() |
| 16078: | { |
| 16079: | /** @var \Illuminate\View\Factory $instance */ |
| 16080: | return $instance->getExtensions(); |
| 16081: | } |
| 16082: | /** |
| 16083: | * Get the engine resolver instance. |
| 16084: | * |
| 16085: | * @return \Illuminate\View\Engines\EngineResolver |
| 16086: | * @static |
| 16087: | */ |
| 16088: | public static function getEngineResolver() |
| 16089: | { |
| 16090: | /** @var \Illuminate\View\Factory $instance */ |
| 16091: | return $instance->getEngineResolver(); |
| 16092: | } |
| 16093: | /** |
| 16094: | * Get the view finder instance. |
| 16095: | * |
| 16096: | * @return \Illuminate\View\ViewFinderInterface |
| 16097: | * @static |
| 16098: | */ |
| 16099: | public static function getFinder() |
| 16100: | { |
| 16101: | /** @var \Illuminate\View\Factory $instance */ |
| 16102: | return $instance->getFinder(); |
| 16103: | } |
| 16104: | /** |
| 16105: | * Set the view finder instance. |
| 16106: | * |
| 16107: | * @param \Illuminate\View\ViewFinderInterface $finder |
| 16108: | * @return void |
| 16109: | * @static |
| 16110: | */ |
| 16111: | public static function setFinder($finder) |
| 16112: | { |
| 16113: | /** @var \Illuminate\View\Factory $instance */ |
| 16114: | $instance->setFinder($finder); |
| 16115: | } |
| 16116: | /** |
| 16117: | * Flush the cache of views located by the finder. |
| 16118: | * |
| 16119: | * @return void |
| 16120: | * @static |
| 16121: | */ |
| 16122: | public static function flushFinderCache() |
| 16123: | { |
| 16124: | /** @var \Illuminate\View\Factory $instance */ |
| 16125: | $instance->flushFinderCache(); |
| 16126: | } |
| 16127: | /** |
| 16128: | * Get the event dispatcher instance. |
| 16129: | * |
| 16130: | * @return \Illuminate\Contracts\Events\Dispatcher |
| 16131: | * @static |
| 16132: | */ |
| 16133: | public static function getDispatcher() |
| 16134: | { |
| 16135: | /** @var \Illuminate\View\Factory $instance */ |
| 16136: | return $instance->getDispatcher(); |
| 16137: | } |
| 16138: | /** |
| 16139: | * Set the event dispatcher instance. |
| 16140: | * |
| 16141: | * @param \Illuminate\Contracts\Events\Dispatcher $events |
| 16142: | * @return void |
| 16143: | * @static |
| 16144: | */ |
| 16145: | public static function setDispatcher($events) |
| 16146: | { |
| 16147: | /** @var \Illuminate\View\Factory $instance */ |
| 16148: | $instance->setDispatcher($events); |
| 16149: | } |
| 16150: | /** |
| 16151: | * Get the IoC container instance. |
| 16152: | * |
| 16153: | * @return \Illuminate\Contracts\Container\Container |
| 16154: | * @static |
| 16155: | */ |
| 16156: | public static function getContainer() |
| 16157: | { |
| 16158: | /** @var \Illuminate\View\Factory $instance */ |
| 16159: | return $instance->getContainer(); |
| 16160: | } |
| 16161: | /** |
| 16162: | * Set the IoC container instance. |
| 16163: | * |
| 16164: | * @param \Illuminate\Contracts\Container\Container $container |
| 16165: | * @return void |
| 16166: | * @static |
| 16167: | */ |
| 16168: | public static function setContainer($container) |
| 16169: | { |
| 16170: | /** @var \Illuminate\View\Factory $instance */ |
| 16171: | $instance->setContainer($container); |
| 16172: | } |
| 16173: | /** |
| 16174: | * Get an item from the shared data. |
| 16175: | * |
| 16176: | * @param string $key |
| 16177: | * @param mixed $default |
| 16178: | * @return mixed |
| 16179: | * @static |
| 16180: | */ |
| 16181: | public static function shared($key, $default = null) |
| 16182: | { |
| 16183: | /** @var \Illuminate\View\Factory $instance */ |
| 16184: | return $instance->shared($key, $default); |
| 16185: | } |
| 16186: | /** |
| 16187: | * Get all of the shared data for the environment. |
| 16188: | * |
| 16189: | * @return array |
| 16190: | * @static |
| 16191: | */ |
| 16192: | public static function getShared() |
| 16193: | { |
| 16194: | /** @var \Illuminate\View\Factory $instance */ |
| 16195: | return $instance->getShared(); |
| 16196: | } |
| 16197: | /** |
| 16198: | * Register a custom macro. |
| 16199: | * |
| 16200: | * @param string $name |
| 16201: | * @param object|callable $macro |
| 16202: | * @return void |
| 16203: | * @static |
| 16204: | */ |
| 16205: | public static function macro($name, $macro) |
| 16206: | { |
| 16207: | \Illuminate\View\Factory::macro($name, $macro); |
| 16208: | } |
| 16209: | /** |
| 16210: | * Mix another object into the class. |
| 16211: | * |
| 16212: | * @param object $mixin |
| 16213: | * @param bool $replace |
| 16214: | * @return void |
| 16215: | * @throws \ReflectionException |
| 16216: | * @static |
| 16217: | */ |
| 16218: | public static function mixin($mixin, $replace = true) |
| 16219: | { |
| 16220: | \Illuminate\View\Factory::mixin($mixin, $replace); |
| 16221: | } |
| 16222: | /** |
| 16223: | * Checks if macro is registered. |
| 16224: | * |
| 16225: | * @param string $name |
| 16226: | * @return bool |
| 16227: | * @static |
| 16228: | */ |
| 16229: | public static function hasMacro($name) |
| 16230: | { |
| 16231: | return \Illuminate\View\Factory::hasMacro($name); |
| 16232: | } |
| 16233: | /** |
| 16234: | * Flush the existing macros. |
| 16235: | * |
| 16236: | * @return void |
| 16237: | * @static |
| 16238: | */ |
| 16239: | public static function flushMacros() |
| 16240: | { |
| 16241: | \Illuminate\View\Factory::flushMacros(); |
| 16242: | } |
| 16243: | /** |
| 16244: | * Start a component rendering process. |
| 16245: | * |
| 16246: | * @param \Illuminate\Contracts\View\View|\Illuminate\Contracts\Support\Htmlable|\Closure|string $view |
| 16247: | * @param array $data |
| 16248: | * @return void |
| 16249: | * @static |
| 16250: | */ |
| 16251: | public static function startComponent($view, $data = []) |
| 16252: | { |
| 16253: | /** @var \Illuminate\View\Factory $instance */ |
| 16254: | $instance->startComponent($view, $data); |
| 16255: | } |
| 16256: | /** |
| 16257: | * Get the first view that actually exists from the given list, and start a component. |
| 16258: | * |
| 16259: | * @param array $names |
| 16260: | * @param array $data |
| 16261: | * @return void |
| 16262: | * @static |
| 16263: | */ |
| 16264: | public static function startComponentFirst($names, $data = []) |
| 16265: | { |
| 16266: | /** @var \Illuminate\View\Factory $instance */ |
| 16267: | $instance->startComponentFirst($names, $data); |
| 16268: | } |
| 16269: | /** |
| 16270: | * Render the current component. |
| 16271: | * |
| 16272: | * @return string |
| 16273: | * @static |
| 16274: | */ |
| 16275: | public static function renderComponent() |
| 16276: | { |
| 16277: | /** @var \Illuminate\View\Factory $instance */ |
| 16278: | return $instance->renderComponent(); |
| 16279: | } |
| 16280: | /** |
| 16281: | * Get an item from the component data that exists above the current component. |
| 16282: | * |
| 16283: | * @param string $key |
| 16284: | * @param mixed $default |
| 16285: | * @return mixed|null |
| 16286: | * @static |
| 16287: | */ |
| 16288: | public static function getConsumableComponentData($key, $default = null) |
| 16289: | { |
| 16290: | /** @var \Illuminate\View\Factory $instance */ |
| 16291: | return $instance->getConsumableComponentData($key, $default); |
| 16292: | } |
| 16293: | /** |
| 16294: | * Start the slot rendering process. |
| 16295: | * |
| 16296: | * @param string $name |
| 16297: | * @param string|null $content |
| 16298: | * @param array $attributes |
| 16299: | * @return void |
| 16300: | * @static |
| 16301: | */ |
| 16302: | public static function slot($name, $content = null, $attributes = []) |
| 16303: | { |
| 16304: | /** @var \Illuminate\View\Factory $instance */ |
| 16305: | $instance->slot($name, $content, $attributes); |
| 16306: | } |
| 16307: | /** |
| 16308: | * Save the slot content for rendering. |
| 16309: | * |
| 16310: | * @return void |
| 16311: | * @static |
| 16312: | */ |
| 16313: | public static function endSlot() |
| 16314: | { |
| 16315: | /** @var \Illuminate\View\Factory $instance */ |
| 16316: | $instance->endSlot(); |
| 16317: | } |
| 16318: | /** |
| 16319: | * Register a view creator event. |
| 16320: | * |
| 16321: | * @param array|string $views |
| 16322: | * @param \Closure|string $callback |
| 16323: | * @return array |
| 16324: | * @static |
| 16325: | */ |
| 16326: | public static function creator($views, $callback) |
| 16327: | { |
| 16328: | /** @var \Illuminate\View\Factory $instance */ |
| 16329: | return $instance->creator($views, $callback); |
| 16330: | } |
| 16331: | /** |
| 16332: | * Register multiple view composers via an array. |
| 16333: | * |
| 16334: | * @param array $composers |
| 16335: | * @return array |
| 16336: | * @static |
| 16337: | */ |
| 16338: | public static function composers($composers) |
| 16339: | { |
| 16340: | /** @var \Illuminate\View\Factory $instance */ |
| 16341: | return $instance->composers($composers); |
| 16342: | } |
| 16343: | /** |
| 16344: | * Register a view composer event. |
| 16345: | * |
| 16346: | * @param array|string $views |
| 16347: | * @param \Closure|string $callback |
| 16348: | * @return array |
| 16349: | * @static |
| 16350: | */ |
| 16351: | public static function composer($views, $callback) |
| 16352: | { |
| 16353: | /** @var \Illuminate\View\Factory $instance */ |
| 16354: | return $instance->composer($views, $callback); |
| 16355: | } |
| 16356: | /** |
| 16357: | * Call the composer for a given view. |
| 16358: | * |
| 16359: | * @param \Illuminate\Contracts\View\View $view |
| 16360: | * @return void |
| 16361: | * @static |
| 16362: | */ |
| 16363: | public static function callComposer($view) |
| 16364: | { |
| 16365: | /** @var \Illuminate\View\Factory $instance */ |
| 16366: | $instance->callComposer($view); |
| 16367: | } |
| 16368: | /** |
| 16369: | * Call the creator for a given view. |
| 16370: | * |
| 16371: | * @param \Illuminate\Contracts\View\View $view |
| 16372: | * @return void |
| 16373: | * @static |
| 16374: | */ |
| 16375: | public static function callCreator($view) |
| 16376: | { |
| 16377: | /** @var \Illuminate\View\Factory $instance */ |
| 16378: | $instance->callCreator($view); |
| 16379: | } |
| 16380: | /** |
| 16381: | * Start injecting content into a section. |
| 16382: | * |
| 16383: | * @param string $section |
| 16384: | * @param string|null $content |
| 16385: | * @return void |
| 16386: | * @static |
| 16387: | */ |
| 16388: | public static function startSection($section, $content = null) |
| 16389: | { |
| 16390: | /** @var \Illuminate\View\Factory $instance */ |
| 16391: | $instance->startSection($section, $content); |
| 16392: | } |
| 16393: | /** |
| 16394: | * Inject inline content into a section. |
| 16395: | * |
| 16396: | * @param string $section |
| 16397: | * @param string $content |
| 16398: | * @return void |
| 16399: | * @static |
| 16400: | */ |
| 16401: | public static function inject($section, $content) |
| 16402: | { |
| 16403: | /** @var \Illuminate\View\Factory $instance */ |
| 16404: | $instance->inject($section, $content); |
| 16405: | } |
| 16406: | /** |
| 16407: | * Stop injecting content into a section and return its contents. |
| 16408: | * |
| 16409: | * @return string |
| 16410: | * @static |
| 16411: | */ |
| 16412: | public static function yieldSection() |
| 16413: | { |
| 16414: | /** @var \Illuminate\View\Factory $instance */ |
| 16415: | return $instance->yieldSection(); |
| 16416: | } |
| 16417: | /** |
| 16418: | * Stop injecting content into a section. |
| 16419: | * |
| 16420: | * @param bool $overwrite |
| 16421: | * @return string |
| 16422: | * @throws \InvalidArgumentException |
| 16423: | * @static |
| 16424: | */ |
| 16425: | public static function stopSection($overwrite = false) |
| 16426: | { |
| 16427: | /** @var \Illuminate\View\Factory $instance */ |
| 16428: | return $instance->stopSection($overwrite); |
| 16429: | } |
| 16430: | /** |
| 16431: | * Stop injecting content into a section and append it. |
| 16432: | * |
| 16433: | * @return string |
| 16434: | * @throws \InvalidArgumentException |
| 16435: | * @static |
| 16436: | */ |
| 16437: | public static function appendSection() |
| 16438: | { |
| 16439: | /** @var \Illuminate\View\Factory $instance */ |
| 16440: | return $instance->appendSection(); |
| 16441: | } |
| 16442: | /** |
| 16443: | * Get the string contents of a section. |
| 16444: | * |
| 16445: | * @param string $section |
| 16446: | * @param string $default |
| 16447: | * @return string |
| 16448: | * @static |
| 16449: | */ |
| 16450: | public static function yieldContent($section, $default = '') |
| 16451: | { |
| 16452: | /** @var \Illuminate\View\Factory $instance */ |
| 16453: | return $instance->yieldContent($section, $default); |
| 16454: | } |
| 16455: | /** |
| 16456: | * Get the parent placeholder for the current request. |
| 16457: | * |
| 16458: | * @param string $section |
| 16459: | * @return string |
| 16460: | * @static |
| 16461: | */ |
| 16462: | public static function parentPlaceholder($section = '') |
| 16463: | { |
| 16464: | return \Illuminate\View\Factory::parentPlaceholder($section); |
| 16465: | } |
| 16466: | /** |
| 16467: | * Check if section exists. |
| 16468: | * |
| 16469: | * @param string $name |
| 16470: | * @return bool |
| 16471: | * @static |
| 16472: | */ |
| 16473: | public static function hasSection($name) |
| 16474: | { |
| 16475: | /** @var \Illuminate\View\Factory $instance */ |
| 16476: | return $instance->hasSection($name); |
| 16477: | } |
| 16478: | /** |
| 16479: | * Check if section does not exist. |
| 16480: | * |
| 16481: | * @param string $name |
| 16482: | * @return bool |
| 16483: | * @static |
| 16484: | */ |
| 16485: | public static function sectionMissing($name) |
| 16486: | { |
| 16487: | /** @var \Illuminate\View\Factory $instance */ |
| 16488: | return $instance->sectionMissing($name); |
| 16489: | } |
| 16490: | /** |
| 16491: | * Get the contents of a section. |
| 16492: | * |
| 16493: | * @param string $name |
| 16494: | * @param string|null $default |
| 16495: | * @return mixed |
| 16496: | * @static |
| 16497: | */ |
| 16498: | public static function getSection($name, $default = null) |
| 16499: | { |
| 16500: | /** @var \Illuminate\View\Factory $instance */ |
| 16501: | return $instance->getSection($name, $default); |
| 16502: | } |
| 16503: | /** |
| 16504: | * Get the entire array of sections. |
| 16505: | * |
| 16506: | * @return array |
| 16507: | * @static |
| 16508: | */ |
| 16509: | public static function getSections() |
| 16510: | { |
| 16511: | /** @var \Illuminate\View\Factory $instance */ |
| 16512: | return $instance->getSections(); |
| 16513: | } |
| 16514: | /** |
| 16515: | * Flush all of the sections. |
| 16516: | * |
| 16517: | * @return void |
| 16518: | * @static |
| 16519: | */ |
| 16520: | public static function flushSections() |
| 16521: | { |
| 16522: | /** @var \Illuminate\View\Factory $instance */ |
| 16523: | $instance->flushSections(); |
| 16524: | } |
| 16525: | /** |
| 16526: | * Add new loop to the stack. |
| 16527: | * |
| 16528: | * @param \Countable|array $data |
| 16529: | * @return void |
| 16530: | * @static |
| 16531: | */ |
| 16532: | public static function addLoop($data) |
| 16533: | { |
| 16534: | /** @var \Illuminate\View\Factory $instance */ |
| 16535: | $instance->addLoop($data); |
| 16536: | } |
| 16537: | /** |
| 16538: | * Increment the top loop's indices. |
| 16539: | * |
| 16540: | * @return void |
| 16541: | * @static |
| 16542: | */ |
| 16543: | public static function incrementLoopIndices() |
| 16544: | { |
| 16545: | /** @var \Illuminate\View\Factory $instance */ |
| 16546: | $instance->incrementLoopIndices(); |
| 16547: | } |
| 16548: | /** |
| 16549: | * Pop a loop from the top of the loop stack. |
| 16550: | * |
| 16551: | * @return void |
| 16552: | * @static |
| 16553: | */ |
| 16554: | public static function popLoop() |
| 16555: | { |
| 16556: | /** @var \Illuminate\View\Factory $instance */ |
| 16557: | $instance->popLoop(); |
| 16558: | } |
| 16559: | /** |
| 16560: | * Get an instance of the last loop in the stack. |
| 16561: | * |
| 16562: | * @return \stdClass|null |
| 16563: | * @static |
| 16564: | */ |
| 16565: | public static function getLastLoop() |
| 16566: | { |
| 16567: | /** @var \Illuminate\View\Factory $instance */ |
| 16568: | return $instance->getLastLoop(); |
| 16569: | } |
| 16570: | /** |
| 16571: | * Get the entire loop stack. |
| 16572: | * |
| 16573: | * @return array |
| 16574: | * @static |
| 16575: | */ |
| 16576: | public static function getLoopStack() |
| 16577: | { |
| 16578: | /** @var \Illuminate\View\Factory $instance */ |
| 16579: | return $instance->getLoopStack(); |
| 16580: | } |
| 16581: | /** |
| 16582: | * Start injecting content into a push section. |
| 16583: | * |
| 16584: | * @param string $section |
| 16585: | * @param string $content |
| 16586: | * @return void |
| 16587: | * @static |
| 16588: | */ |
| 16589: | public static function startPush($section, $content = '') |
| 16590: | { |
| 16591: | /** @var \Illuminate\View\Factory $instance */ |
| 16592: | $instance->startPush($section, $content); |
| 16593: | } |
| 16594: | /** |
| 16595: | * Stop injecting content into a push section. |
| 16596: | * |
| 16597: | * @return string |
| 16598: | * @throws \InvalidArgumentException |
| 16599: | * @static |
| 16600: | */ |
| 16601: | public static function stopPush() |
| 16602: | { |
| 16603: | /** @var \Illuminate\View\Factory $instance */ |
| 16604: | return $instance->stopPush(); |
| 16605: | } |
| 16606: | /** |
| 16607: | * Start prepending content into a push section. |
| 16608: | * |
| 16609: | * @param string $section |
| 16610: | * @param string $content |
| 16611: | * @return void |
| 16612: | * @static |
| 16613: | */ |
| 16614: | public static function startPrepend($section, $content = '') |
| 16615: | { |
| 16616: | /** @var \Illuminate\View\Factory $instance */ |
| 16617: | $instance->startPrepend($section, $content); |
| 16618: | } |
| 16619: | /** |
| 16620: | * Stop prepending content into a push section. |
| 16621: | * |
| 16622: | * @return string |
| 16623: | * @throws \InvalidArgumentException |
| 16624: | * @static |
| 16625: | */ |
| 16626: | public static function stopPrepend() |
| 16627: | { |
| 16628: | /** @var \Illuminate\View\Factory $instance */ |
| 16629: | return $instance->stopPrepend(); |
| 16630: | } |
| 16631: | /** |
| 16632: | * Get the string contents of a push section. |
| 16633: | * |
| 16634: | * @param string $section |
| 16635: | * @param string $default |
| 16636: | * @return string |
| 16637: | * @static |
| 16638: | */ |
| 16639: | public static function yieldPushContent($section, $default = '') |
| 16640: | { |
| 16641: | /** @var \Illuminate\View\Factory $instance */ |
| 16642: | return $instance->yieldPushContent($section, $default); |
| 16643: | } |
| 16644: | /** |
| 16645: | * Flush all of the stacks. |
| 16646: | * |
| 16647: | * @return void |
| 16648: | * @static |
| 16649: | */ |
| 16650: | public static function flushStacks() |
| 16651: | { |
| 16652: | /** @var \Illuminate\View\Factory $instance */ |
| 16653: | $instance->flushStacks(); |
| 16654: | } |
| 16655: | /** |
| 16656: | * Start a translation block. |
| 16657: | * |
| 16658: | * @param array $replacements |
| 16659: | * @return void |
| 16660: | * @static |
| 16661: | */ |
| 16662: | public static function startTranslation($replacements = []) |
| 16663: | { |
| 16664: | /** @var \Illuminate\View\Factory $instance */ |
| 16665: | $instance->startTranslation($replacements); |
| 16666: | } |
| 16667: | /** |
| 16668: | * Render the current translation. |
| 16669: | * |
| 16670: | * @return string |
| 16671: | * @static |
| 16672: | */ |
| 16673: | public static function renderTranslation() |
| 16674: | { |
| 16675: | /** @var \Illuminate\View\Factory $instance */ |
| 16676: | return $instance->renderTranslation(); |
| 16677: | } |
| 16678: | |
| 16679: | } |
| 16680: | |
| 16681: | } |
| 16682: | |
| 16683: | namespace Illuminate\Support { |
| 16684: | /** |
| 16685: | * |
| 16686: | * |
| 16687: | */ |
| 16688: | class Arr { |
| 16689: | |
| 16690: | } |
| 16691: | /** |
| 16692: | * |
| 16693: | * |
| 16694: | */ |
| 16695: | class Str { |
| 16696: | /** |
| 16697: | * |
| 16698: | * |
| 16699: | * @see \Calebporzio\AwesomeHelpers\StrMacros::extract() |
| 16700: | * @param mixed $string |
| 16701: | * @param mixed $pattern |
| 16702: | * @static |
| 16703: | */ |
| 16704: | public static function extract($string, $pattern) |
| 16705: | { |
| 16706: | return \Illuminate\Support\Str::extract($string, $pattern); |
| 16707: | } |
| 16708: | /** |
| 16709: | * |
| 16710: | * |
| 16711: | * @see \Calebporzio\AwesomeHelpers\StrMacros::validate() |
| 16712: | * @param mixed $data |
| 16713: | * @param mixed $rules |
| 16714: | * @static |
| 16715: | */ |
| 16716: | public static function validate($data, $rules) |
| 16717: | { |
| 16718: | return \Illuminate\Support\Str::validate($data, $rules); |
| 16719: | } |
| 16720: | /** |
| 16721: | * |
| 16722: | * |
| 16723: | * @see \Calebporzio\AwesomeHelpers\StrMacros::wrap() |
| 16724: | * @param mixed $value |
| 16725: | * @param mixed $cap |
| 16726: | * @static |
| 16727: | */ |
| 16728: | public static function wrap($value, $cap) |
| 16729: | { |
| 16730: | return \Illuminate\Support\Str::wrap($value, $cap); |
| 16731: | } |
| 16732: | /** |
| 16733: | * |
| 16734: | * |
| 16735: | * @see \Filament\Support\SupportServiceProvider::packageBooted() |
| 16736: | * @param string $html |
| 16737: | * @return string |
| 16738: | * @static |
| 16739: | */ |
| 16740: | public static function sanitizeHtml($html) |
| 16741: | { |
| 16742: | return \Illuminate\Support\Str::sanitizeHtml($html); |
| 16743: | } |
| 16744: | |
| 16745: | } |
| 16746: | /** |
| 16747: | * |
| 16748: | * |
| 16749: | * @template TKey of array-key |
| 16750: | * @template TValue |
| 16751: | * @implements \ArrayAccess<TKey, TValue> |
| 16752: | * @implements \Illuminate\Support\Enumerable<TKey, TValue> |
| 16753: | */ |
| 16754: | class Collection { |
| 16755: | /** |
| 16756: | * |
| 16757: | * |
| 16758: | * @see \Spatie\LaravelRay\RayServiceProvider::registerMacros() |
| 16759: | * @param string $description |
| 16760: | * @static |
| 16761: | */ |
| 16762: | public static function ray($description = '') |
| 16763: | { |
| 16764: | return \Illuminate\Support\Collection::ray($description); |
| 16765: | } |
| 16766: | |
| 16767: | } |
| 16768: | /** |
| 16769: | * |
| 16770: | * |
| 16771: | */ |
| 16772: | class Stringable { |
| 16773: | /** |
| 16774: | * |
| 16775: | * |
| 16776: | * @see \Spatie\LaravelRay\RayServiceProvider::registerMacros() |
| 16777: | * @param string $description |
| 16778: | * @static |
| 16779: | */ |
| 16780: | public static function ray($description = '') |
| 16781: | { |
| 16782: | return \Illuminate\Support\Stringable::ray($description); |
| 16783: | } |
| 16784: | /** |
| 16785: | * |
| 16786: | * |
| 16787: | * @see \Filament\Support\SupportServiceProvider::packageBooted() |
| 16788: | * @return \Illuminate\Support\Stringable |
| 16789: | * @static |
| 16790: | */ |
| 16791: | public static function sanitizeHtml() |
| 16792: | { |
| 16793: | return \Illuminate\Support\Stringable::sanitizeHtml(); |
| 16794: | } |
| 16795: | |
| 16796: | } |
| 16797: | |
| 16798: | } |
| 16799: | |
| 16800: | namespace Clockwork\Support\Laravel { |
| 16801: | /** |
| 16802: | * |
| 16803: | * |
| 16804: | */ |
| 16805: | class Facade { |
| 16806: | /** |
| 16807: | * |
| 16808: | * |
| 16809: | * @static |
| 16810: | */ |
| 16811: | public static function addDataSource($dataSource) |
| 16812: | { |
| 16813: | /** @var \Clockwork\Clockwork $instance */ |
| 16814: | return $instance->addDataSource($dataSource); |
| 16815: | } |
| 16816: | /** |
| 16817: | * |
| 16818: | * |
| 16819: | * @static |
| 16820: | */ |
| 16821: | public static function resolveRequest() |
| 16822: | { |
| 16823: | /** @var \Clockwork\Clockwork $instance */ |
| 16824: | return $instance->resolveRequest(); |
| 16825: | } |
| 16826: | /** |
| 16827: | * |
| 16828: | * |
| 16829: | * @static |
| 16830: | */ |
| 16831: | public static function resolveAsCommand($name, $exitCode = null, $arguments = [], $options = [], $argumentsDefaults = [], $optionsDefaults = [], $output = null) |
| 16832: | { |
| 16833: | /** @var \Clockwork\Clockwork $instance */ |
| 16834: | return $instance->resolveAsCommand($name, $exitCode, $arguments, $options, $argumentsDefaults, $optionsDefaults, $output); |
| 16835: | } |
| 16836: | /** |
| 16837: | * |
| 16838: | * |
| 16839: | * @static |
| 16840: | */ |
| 16841: | public static function resolveAsQueueJob($name, $description = null, $status = 'processed', $payload = [], $queue = null, $connection = null, $options = []) |
| 16842: | { |
| 16843: | /** @var \Clockwork\Clockwork $instance */ |
| 16844: | return $instance->resolveAsQueueJob($name, $description, $status, $payload, $queue, $connection, $options); |
| 16845: | } |
| 16846: | /** |
| 16847: | * |
| 16848: | * |
| 16849: | * @static |
| 16850: | */ |
| 16851: | public static function resolveAsTest($name, $status = 'passed', $statusMessage = null, $asserts = []) |
| 16852: | { |
| 16853: | /** @var \Clockwork\Clockwork $instance */ |
| 16854: | return $instance->resolveAsTest($name, $status, $statusMessage, $asserts); |
| 16855: | } |
| 16856: | /** |
| 16857: | * |
| 16858: | * |
| 16859: | * @static |
| 16860: | */ |
| 16861: | public static function extendRequest($request = null) |
| 16862: | { |
| 16863: | /** @var \Clockwork\Clockwork $instance */ |
| 16864: | return $instance->extendRequest($request); |
| 16865: | } |
| 16866: | /** |
| 16867: | * |
| 16868: | * |
| 16869: | * @static |
| 16870: | */ |
| 16871: | public static function storeRequest() |
| 16872: | { |
| 16873: | /** @var \Clockwork\Clockwork $instance */ |
| 16874: | return $instance->storeRequest(); |
| 16875: | } |
| 16876: | /** |
| 16877: | * |
| 16878: | * |
| 16879: | * @static |
| 16880: | */ |
| 16881: | public static function reset() |
| 16882: | { |
| 16883: | /** @var \Clockwork\Clockwork $instance */ |
| 16884: | return $instance->reset(); |
| 16885: | } |
| 16886: | /** |
| 16887: | * |
| 16888: | * |
| 16889: | * @static |
| 16890: | */ |
| 16891: | public static function request($request = null) |
| 16892: | { |
| 16893: | /** @var \Clockwork\Clockwork $instance */ |
| 16894: | return $instance->request($request); |
| 16895: | } |
| 16896: | /** |
| 16897: | * |
| 16898: | * |
| 16899: | * @static |
| 16900: | */ |
| 16901: | public static function log($level = null, $message = null, $context = []) |
| 16902: | { |
| 16903: | /** @var \Clockwork\Clockwork $instance */ |
| 16904: | return $instance->log($level, $message, $context); |
| 16905: | } |
| 16906: | /** |
| 16907: | * |
| 16908: | * |
| 16909: | * @static |
| 16910: | */ |
| 16911: | public static function timeline() |
| 16912: | { |
| 16913: | /** @var \Clockwork\Clockwork $instance */ |
| 16914: | return $instance->timeline(); |
| 16915: | } |
| 16916: | /** |
| 16917: | * |
| 16918: | * |
| 16919: | * @static |
| 16920: | */ |
| 16921: | public static function event($description, $data = []) |
| 16922: | { |
| 16923: | /** @var \Clockwork\Clockwork $instance */ |
| 16924: | return $instance->event($description, $data); |
| 16925: | } |
| 16926: | /** |
| 16927: | * |
| 16928: | * |
| 16929: | * @static |
| 16930: | */ |
| 16931: | public static function shouldCollect($shouldCollect = null) |
| 16932: | { |
| 16933: | /** @var \Clockwork\Clockwork $instance */ |
| 16934: | return $instance->shouldCollect($shouldCollect); |
| 16935: | } |
| 16936: | /** |
| 16937: | * |
| 16938: | * |
| 16939: | * @static |
| 16940: | */ |
| 16941: | public static function shouldRecord($shouldRecord = null) |
| 16942: | { |
| 16943: | /** @var \Clockwork\Clockwork $instance */ |
| 16944: | return $instance->shouldRecord($shouldRecord); |
| 16945: | } |
| 16946: | /** |
| 16947: | * |
| 16948: | * |
| 16949: | * @static |
| 16950: | */ |
| 16951: | public static function dataSources($dataSources = null) |
| 16952: | { |
| 16953: | /** @var \Clockwork\Clockwork $instance */ |
| 16954: | return $instance->dataSources($dataSources); |
| 16955: | } |
| 16956: | /** |
| 16957: | * |
| 16958: | * |
| 16959: | * @static |
| 16960: | */ |
| 16961: | public static function storage($storage = null) |
| 16962: | { |
| 16963: | /** @var \Clockwork\Clockwork $instance */ |
| 16964: | return $instance->storage($storage); |
| 16965: | } |
| 16966: | /** |
| 16967: | * |
| 16968: | * |
| 16969: | * @static |
| 16970: | */ |
| 16971: | public static function authenticator($authenticator = null) |
| 16972: | { |
| 16973: | /** @var \Clockwork\Clockwork $instance */ |
| 16974: | return $instance->authenticator($authenticator); |
| 16975: | } |
| 16976: | /** |
| 16977: | * |
| 16978: | * |
| 16979: | * @static |
| 16980: | */ |
| 16981: | public static function getDataSources() |
| 16982: | { |
| 16983: | /** @var \Clockwork\Clockwork $instance */ |
| 16984: | return $instance->getDataSources(); |
| 16985: | } |
| 16986: | /** |
| 16987: | * |
| 16988: | * |
| 16989: | * @static |
| 16990: | */ |
| 16991: | public static function getRequest() |
| 16992: | { |
| 16993: | /** @var \Clockwork\Clockwork $instance */ |
| 16994: | return $instance->getRequest(); |
| 16995: | } |
| 16996: | /** |
| 16997: | * |
| 16998: | * |
| 16999: | * @static |
| 17000: | */ |
| 17001: | public static function setRequest($request) |
| 17002: | { |
| 17003: | /** @var \Clockwork\Clockwork $instance */ |
| 17004: | return $instance->setRequest($request); |
| 17005: | } |
| 17006: | /** |
| 17007: | * |
| 17008: | * |
| 17009: | * @static |
| 17010: | */ |
| 17011: | public static function getStorage() |
| 17012: | { |
| 17013: | /** @var \Clockwork\Clockwork $instance */ |
| 17014: | return $instance->getStorage(); |
| 17015: | } |
| 17016: | /** |
| 17017: | * |
| 17018: | * |
| 17019: | * @static |
| 17020: | */ |
| 17021: | public static function setStorage($storage) |
| 17022: | { |
| 17023: | /** @var \Clockwork\Clockwork $instance */ |
| 17024: | return $instance->setStorage($storage); |
| 17025: | } |
| 17026: | /** |
| 17027: | * |
| 17028: | * |
| 17029: | * @static |
| 17030: | */ |
| 17031: | public static function getAuthenticator() |
| 17032: | { |
| 17033: | /** @var \Clockwork\Clockwork $instance */ |
| 17034: | return $instance->getAuthenticator(); |
| 17035: | } |
| 17036: | /** |
| 17037: | * |
| 17038: | * |
| 17039: | * @static |
| 17040: | */ |
| 17041: | public static function setAuthenticator($authenticator) |
| 17042: | { |
| 17043: | /** @var \Clockwork\Clockwork $instance */ |
| 17044: | return $instance->setAuthenticator($authenticator); |
| 17045: | } |
| 17046: | |
| 17047: | } |
| 17048: | |
| 17049: | } |
| 17050: | |
| 17051: | namespace Jenssegers\Agent\Facades { |
| 17052: | /** |
| 17053: | * |
| 17054: | * |
| 17055: | */ |
| 17056: | class Agent { |
| 17057: | /** |
| 17058: | * Get all detection rules. These rules include the additional |
| 17059: | * platforms and browsers and utilities. |
| 17060: | * |
| 17061: | * @return array |
| 17062: | * @static |
| 17063: | */ |
| 17064: | public static function getDetectionRulesExtended() |
| 17065: | { |
| 17066: | return \Jenssegers\Agent\Agent::getDetectionRulesExtended(); |
| 17067: | } |
| 17068: | /** |
| 17069: | * |
| 17070: | * |
| 17071: | * @static |
| 17072: | */ |
| 17073: | public static function getRules() |
| 17074: | { |
| 17075: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17076: | return $instance->getRules(); |
| 17077: | } |
| 17078: | /** |
| 17079: | * |
| 17080: | * |
| 17081: | * @return \Jaybizzle\CrawlerDetect\CrawlerDetect |
| 17082: | * @static |
| 17083: | */ |
| 17084: | public static function getCrawlerDetect() |
| 17085: | { |
| 17086: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17087: | return $instance->getCrawlerDetect(); |
| 17088: | } |
| 17089: | /** |
| 17090: | * |
| 17091: | * |
| 17092: | * @static |
| 17093: | */ |
| 17094: | public static function getBrowsers() |
| 17095: | { |
| 17096: | return \Jenssegers\Agent\Agent::getBrowsers(); |
| 17097: | } |
| 17098: | /** |
| 17099: | * |
| 17100: | * |
| 17101: | * @static |
| 17102: | */ |
| 17103: | public static function getOperatingSystems() |
| 17104: | { |
| 17105: | return \Jenssegers\Agent\Agent::getOperatingSystems(); |
| 17106: | } |
| 17107: | /** |
| 17108: | * |
| 17109: | * |
| 17110: | * @static |
| 17111: | */ |
| 17112: | public static function getPlatforms() |
| 17113: | { |
| 17114: | return \Jenssegers\Agent\Agent::getPlatforms(); |
| 17115: | } |
| 17116: | /** |
| 17117: | * |
| 17118: | * |
| 17119: | * @static |
| 17120: | */ |
| 17121: | public static function getDesktopDevices() |
| 17122: | { |
| 17123: | return \Jenssegers\Agent\Agent::getDesktopDevices(); |
| 17124: | } |
| 17125: | /** |
| 17126: | * |
| 17127: | * |
| 17128: | * @static |
| 17129: | */ |
| 17130: | public static function getProperties() |
| 17131: | { |
| 17132: | return \Jenssegers\Agent\Agent::getProperties(); |
| 17133: | } |
| 17134: | /** |
| 17135: | * Get accept languages. |
| 17136: | * |
| 17137: | * @param string $acceptLanguage |
| 17138: | * @return array |
| 17139: | * @static |
| 17140: | */ |
| 17141: | public static function languages($acceptLanguage = null) |
| 17142: | { |
| 17143: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17144: | return $instance->languages($acceptLanguage); |
| 17145: | } |
| 17146: | /** |
| 17147: | * Get the browser name. |
| 17148: | * |
| 17149: | * @param string|null $userAgent |
| 17150: | * @return string|bool |
| 17151: | * @static |
| 17152: | */ |
| 17153: | public static function browser($userAgent = null) |
| 17154: | { |
| 17155: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17156: | return $instance->browser($userAgent); |
| 17157: | } |
| 17158: | /** |
| 17159: | * Get the platform name. |
| 17160: | * |
| 17161: | * @param string|null $userAgent |
| 17162: | * @return string|bool |
| 17163: | * @static |
| 17164: | */ |
| 17165: | public static function platform($userAgent = null) |
| 17166: | { |
| 17167: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17168: | return $instance->platform($userAgent); |
| 17169: | } |
| 17170: | /** |
| 17171: | * Get the device name. |
| 17172: | * |
| 17173: | * @param string|null $userAgent |
| 17174: | * @return string|bool |
| 17175: | * @static |
| 17176: | */ |
| 17177: | public static function device($userAgent = null) |
| 17178: | { |
| 17179: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17180: | return $instance->device($userAgent); |
| 17181: | } |
| 17182: | /** |
| 17183: | * Check if the device is a desktop computer. |
| 17184: | * |
| 17185: | * @param string|null $userAgent deprecated |
| 17186: | * @param array $httpHeaders deprecated |
| 17187: | * @return bool |
| 17188: | * @static |
| 17189: | */ |
| 17190: | public static function isDesktop($userAgent = null, $httpHeaders = null) |
| 17191: | { |
| 17192: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17193: | return $instance->isDesktop($userAgent, $httpHeaders); |
| 17194: | } |
| 17195: | /** |
| 17196: | * Check if the device is a mobile phone. |
| 17197: | * |
| 17198: | * @param string|null $userAgent deprecated |
| 17199: | * @param array $httpHeaders deprecated |
| 17200: | * @return bool |
| 17201: | * @static |
| 17202: | */ |
| 17203: | public static function isPhone($userAgent = null, $httpHeaders = null) |
| 17204: | { |
| 17205: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17206: | return $instance->isPhone($userAgent, $httpHeaders); |
| 17207: | } |
| 17208: | /** |
| 17209: | * Get the robot name. |
| 17210: | * |
| 17211: | * @param string|null $userAgent |
| 17212: | * @return string|bool |
| 17213: | * @static |
| 17214: | */ |
| 17215: | public static function robot($userAgent = null) |
| 17216: | { |
| 17217: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17218: | return $instance->robot($userAgent); |
| 17219: | } |
| 17220: | /** |
| 17221: | * Check if device is a robot. |
| 17222: | * |
| 17223: | * @param string|null $userAgent |
| 17224: | * @return bool |
| 17225: | * @static |
| 17226: | */ |
| 17227: | public static function isRobot($userAgent = null) |
| 17228: | { |
| 17229: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17230: | return $instance->isRobot($userAgent); |
| 17231: | } |
| 17232: | /** |
| 17233: | * Get the device type |
| 17234: | * |
| 17235: | * @param null $userAgent |
| 17236: | * @param null $httpHeaders |
| 17237: | * @return string |
| 17238: | * @static |
| 17239: | */ |
| 17240: | public static function deviceType($userAgent = null, $httpHeaders = null) |
| 17241: | { |
| 17242: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17243: | return $instance->deviceType($userAgent, $httpHeaders); |
| 17244: | } |
| 17245: | /** |
| 17246: | * |
| 17247: | * |
| 17248: | * @static |
| 17249: | */ |
| 17250: | public static function version($propertyName, $type = 'text') |
| 17251: | { |
| 17252: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17253: | return $instance->version($propertyName, $type); |
| 17254: | } |
| 17255: | /** |
| 17256: | * Get the current script version. |
| 17257: | * |
| 17258: | * This is useful for the demo.php file, |
| 17259: | * so people can check on what version they are testing |
| 17260: | * for mobile devices. |
| 17261: | * |
| 17262: | * @return string The version number in semantic version format. |
| 17263: | * @static |
| 17264: | */ |
| 17265: | public static function getScriptVersion() |
| 17266: | { //Method inherited from \Mobile_Detect |
| 17267: | return \Jenssegers\Agent\Agent::getScriptVersion(); |
| 17268: | } |
| 17269: | /** |
| 17270: | * Set the HTTP Headers. Must be PHP-flavored. This method will reset existing headers. |
| 17271: | * |
| 17272: | * @param array $httpHeaders The headers to set. If null, then using PHP's _SERVER to extract |
| 17273: | * the headers. The default null is left for backwards compatibility. |
| 17274: | * @static |
| 17275: | */ |
| 17276: | public static function setHttpHeaders($httpHeaders = null) |
| 17277: | { //Method inherited from \Mobile_Detect |
| 17278: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17279: | return $instance->setHttpHeaders($httpHeaders); |
| 17280: | } |
| 17281: | /** |
| 17282: | * Retrieves the HTTP headers. |
| 17283: | * |
| 17284: | * @return array |
| 17285: | * @static |
| 17286: | */ |
| 17287: | public static function getHttpHeaders() |
| 17288: | { //Method inherited from \Mobile_Detect |
| 17289: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17290: | return $instance->getHttpHeaders(); |
| 17291: | } |
| 17292: | /** |
| 17293: | * Retrieves a particular header. If it doesn't exist, no exception/error is caused. |
| 17294: | * |
| 17295: | * Simply null is returned. |
| 17296: | * |
| 17297: | * @param string $header The name of the header to retrieve. Can be HTTP compliant such as |
| 17298: | * "User-Agent" or "X-Device-User-Agent" or can be php-esque with the |
| 17299: | * all-caps, HTTP_ prefixed, underscore seperated awesomeness. |
| 17300: | * @return string|null The value of the header. |
| 17301: | * @static |
| 17302: | */ |
| 17303: | public static function getHttpHeader($header) |
| 17304: | { //Method inherited from \Mobile_Detect |
| 17305: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17306: | return $instance->getHttpHeader($header); |
| 17307: | } |
| 17308: | /** |
| 17309: | * |
| 17310: | * |
| 17311: | * @static |
| 17312: | */ |
| 17313: | public static function getMobileHeaders() |
| 17314: | { //Method inherited from \Mobile_Detect |
| 17315: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17316: | return $instance->getMobileHeaders(); |
| 17317: | } |
| 17318: | /** |
| 17319: | * Get all possible HTTP headers that |
| 17320: | * can contain the User-Agent string. |
| 17321: | * |
| 17322: | * @return array List of HTTP headers. |
| 17323: | * @static |
| 17324: | */ |
| 17325: | public static function getUaHttpHeaders() |
| 17326: | { //Method inherited from \Mobile_Detect |
| 17327: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17328: | return $instance->getUaHttpHeaders(); |
| 17329: | } |
| 17330: | /** |
| 17331: | * Set CloudFront headers |
| 17332: | * http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/header-caching.html#header-caching-web-device |
| 17333: | * |
| 17334: | * @param array $cfHeaders List of HTTP headers |
| 17335: | * @return boolean If there were CloudFront headers to be set |
| 17336: | * @static |
| 17337: | */ |
| 17338: | public static function setCfHeaders($cfHeaders = null) |
| 17339: | { //Method inherited from \Mobile_Detect |
| 17340: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17341: | return $instance->setCfHeaders($cfHeaders); |
| 17342: | } |
| 17343: | /** |
| 17344: | * Retrieves the cloudfront headers. |
| 17345: | * |
| 17346: | * @return array |
| 17347: | * @static |
| 17348: | */ |
| 17349: | public static function getCfHeaders() |
| 17350: | { //Method inherited from \Mobile_Detect |
| 17351: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17352: | return $instance->getCfHeaders(); |
| 17353: | } |
| 17354: | /** |
| 17355: | * Set the User-Agent to be used. |
| 17356: | * |
| 17357: | * @param string $userAgent The user agent string to set. |
| 17358: | * @return string|null |
| 17359: | * @static |
| 17360: | */ |
| 17361: | public static function setUserAgent($userAgent = null) |
| 17362: | { //Method inherited from \Mobile_Detect |
| 17363: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17364: | return $instance->setUserAgent($userAgent); |
| 17365: | } |
| 17366: | /** |
| 17367: | * Retrieve the User-Agent. |
| 17368: | * |
| 17369: | * @return string|null The user agent if it's set. |
| 17370: | * @static |
| 17371: | */ |
| 17372: | public static function getUserAgent() |
| 17373: | { //Method inherited from \Mobile_Detect |
| 17374: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17375: | return $instance->getUserAgent(); |
| 17376: | } |
| 17377: | /** |
| 17378: | * Set the detection type. Must be one of self::DETECTION_TYPE_MOBILE or |
| 17379: | * self::DETECTION_TYPE_EXTENDED. Otherwise, nothing is set. |
| 17380: | * |
| 17381: | * @deprecated since version 2.6.9 |
| 17382: | * @param string $type The type. Must be a self::DETECTION_TYPE_* constant. The default |
| 17383: | * parameter is null which will default to self::DETECTION_TYPE_MOBILE. |
| 17384: | * @static |
| 17385: | */ |
| 17386: | public static function setDetectionType($type = null) |
| 17387: | { //Method inherited from \Mobile_Detect |
| 17388: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17389: | return $instance->setDetectionType($type); |
| 17390: | } |
| 17391: | /** |
| 17392: | * |
| 17393: | * |
| 17394: | * @static |
| 17395: | */ |
| 17396: | public static function getMatchingRegex() |
| 17397: | { //Method inherited from \Mobile_Detect |
| 17398: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17399: | return $instance->getMatchingRegex(); |
| 17400: | } |
| 17401: | /** |
| 17402: | * |
| 17403: | * |
| 17404: | * @static |
| 17405: | */ |
| 17406: | public static function getMatchesArray() |
| 17407: | { //Method inherited from \Mobile_Detect |
| 17408: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17409: | return $instance->getMatchesArray(); |
| 17410: | } |
| 17411: | /** |
| 17412: | * Retrieve the list of known phone devices. |
| 17413: | * |
| 17414: | * @return array List of phone devices. |
| 17415: | * @static |
| 17416: | */ |
| 17417: | public static function getPhoneDevices() |
| 17418: | { //Method inherited from \Mobile_Detect |
| 17419: | return \Jenssegers\Agent\Agent::getPhoneDevices(); |
| 17420: | } |
| 17421: | /** |
| 17422: | * Retrieve the list of known tablet devices. |
| 17423: | * |
| 17424: | * @return array List of tablet devices. |
| 17425: | * @static |
| 17426: | */ |
| 17427: | public static function getTabletDevices() |
| 17428: | { //Method inherited from \Mobile_Detect |
| 17429: | return \Jenssegers\Agent\Agent::getTabletDevices(); |
| 17430: | } |
| 17431: | /** |
| 17432: | * Alias for getBrowsers() method. |
| 17433: | * |
| 17434: | * @return array List of user agents. |
| 17435: | * @static |
| 17436: | */ |
| 17437: | public static function getUserAgents() |
| 17438: | { //Method inherited from \Mobile_Detect |
| 17439: | return \Jenssegers\Agent\Agent::getUserAgents(); |
| 17440: | } |
| 17441: | /** |
| 17442: | * Retrieve the list of known utilities. |
| 17443: | * |
| 17444: | * @return array List of utilities. |
| 17445: | * @static |
| 17446: | */ |
| 17447: | public static function getUtilities() |
| 17448: | { //Method inherited from \Mobile_Detect |
| 17449: | return \Jenssegers\Agent\Agent::getUtilities(); |
| 17450: | } |
| 17451: | /** |
| 17452: | * Method gets the mobile detection rules. This method is used for the magic methods $detect->is*(). |
| 17453: | * |
| 17454: | * @deprecated since version 2.6.9 |
| 17455: | * @return array All the rules (but not extended). |
| 17456: | * @static |
| 17457: | */ |
| 17458: | public static function getMobileDetectionRules() |
| 17459: | { //Method inherited from \Mobile_Detect |
| 17460: | return \Jenssegers\Agent\Agent::getMobileDetectionRules(); |
| 17461: | } |
| 17462: | /** |
| 17463: | * Method gets the mobile detection rules + utilities. |
| 17464: | * |
| 17465: | * The reason this is separate is because utilities rules |
| 17466: | * don't necessary imply mobile. This method is used inside |
| 17467: | * the new $detect->is('stuff') method. |
| 17468: | * |
| 17469: | * @deprecated since version 2.6.9 |
| 17470: | * @return array All the rules + extended. |
| 17471: | * @static |
| 17472: | */ |
| 17473: | public static function getMobileDetectionRulesExtended() |
| 17474: | { //Method inherited from \Mobile_Detect |
| 17475: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17476: | return $instance->getMobileDetectionRulesExtended(); |
| 17477: | } |
| 17478: | /** |
| 17479: | * Check the HTTP headers for signs of mobile. |
| 17480: | * |
| 17481: | * This is the fastest mobile check possible; it's used |
| 17482: | * inside isMobile() method. |
| 17483: | * |
| 17484: | * @return bool |
| 17485: | * @static |
| 17486: | */ |
| 17487: | public static function checkHttpHeadersForMobile() |
| 17488: | { //Method inherited from \Mobile_Detect |
| 17489: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17490: | return $instance->checkHttpHeadersForMobile(); |
| 17491: | } |
| 17492: | /** |
| 17493: | * Check if the device is mobile. |
| 17494: | * |
| 17495: | * Returns true if any type of mobile device detected, including special ones |
| 17496: | * |
| 17497: | * @param null $userAgent deprecated |
| 17498: | * @param null $httpHeaders deprecated |
| 17499: | * @return bool |
| 17500: | * @static |
| 17501: | */ |
| 17502: | public static function isMobile($userAgent = null, $httpHeaders = null) |
| 17503: | { //Method inherited from \Mobile_Detect |
| 17504: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17505: | return $instance->isMobile($userAgent, $httpHeaders); |
| 17506: | } |
| 17507: | /** |
| 17508: | * Check if the device is a tablet. |
| 17509: | * |
| 17510: | * Return true if any type of tablet device is detected. |
| 17511: | * |
| 17512: | * @param string $userAgent deprecated |
| 17513: | * @param array $httpHeaders deprecated |
| 17514: | * @return bool |
| 17515: | * @static |
| 17516: | */ |
| 17517: | public static function isTablet($userAgent = null, $httpHeaders = null) |
| 17518: | { //Method inherited from \Mobile_Detect |
| 17519: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17520: | return $instance->isTablet($userAgent, $httpHeaders); |
| 17521: | } |
| 17522: | /** |
| 17523: | * This method checks for a certain property in the |
| 17524: | * userAgent. |
| 17525: | * |
| 17526: | * @todo : The httpHeaders part is not yet used. |
| 17527: | * @param string $key |
| 17528: | * @param string $userAgent deprecated |
| 17529: | * @param string $httpHeaders deprecated |
| 17530: | * @return bool|int|null |
| 17531: | * @static |
| 17532: | */ |
| 17533: | public static function is($key, $userAgent = null, $httpHeaders = null) |
| 17534: | { //Method inherited from \Mobile_Detect |
| 17535: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17536: | return $instance->is($key, $userAgent, $httpHeaders); |
| 17537: | } |
| 17538: | /** |
| 17539: | * Some detection rules are relative (not standard), |
| 17540: | * because of the diversity of devices, vendors and |
| 17541: | * their conventions in representing the User-Agent or |
| 17542: | * the HTTP headers. |
| 17543: | * |
| 17544: | * This method will be used to check custom regexes against |
| 17545: | * the User-Agent string. |
| 17546: | * |
| 17547: | * @param $regex |
| 17548: | * @param string $userAgent |
| 17549: | * @return bool |
| 17550: | * @todo : search in the HTTP headers too. |
| 17551: | * @static |
| 17552: | */ |
| 17553: | public static function match($regex, $userAgent = null) |
| 17554: | { //Method inherited from \Mobile_Detect |
| 17555: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17556: | return $instance->match($regex, $userAgent); |
| 17557: | } |
| 17558: | /** |
| 17559: | * Prepare the version number. |
| 17560: | * |
| 17561: | * @todo Remove the error supression from str_replace() call. |
| 17562: | * @param string $ver The string version, like "2.6.21.2152"; |
| 17563: | * @return float |
| 17564: | * @static |
| 17565: | */ |
| 17566: | public static function prepareVersionNo($ver) |
| 17567: | { //Method inherited from \Mobile_Detect |
| 17568: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17569: | return $instance->prepareVersionNo($ver); |
| 17570: | } |
| 17571: | /** |
| 17572: | * Retrieve the mobile grading, using self::MOBILE_GRADE_* constants. |
| 17573: | * |
| 17574: | * @deprecated This is no longer being maintained, it was an experiment at the time. |
| 17575: | * @return string One of the self::MOBILE_GRADE_* constants. |
| 17576: | * @static |
| 17577: | */ |
| 17578: | public static function mobileGrade() |
| 17579: | { //Method inherited from \Mobile_Detect |
| 17580: | /** @var \Jenssegers\Agent\Agent $instance */ |
| 17581: | return $instance->mobileGrade(); |
| 17582: | } |
| 17583: | |
| 17584: | } |
| 17585: | |
| 17586: | } |
| 17587: | |
| 17588: | namespace Livewire { |
| 17589: | /** |
| 17590: | * |
| 17591: | * |
| 17592: | * @see \Livewire\LivewireManager |
| 17593: | */ |
| 17594: | class Livewire { |
| 17595: | /** |
| 17596: | * |
| 17597: | * |
| 17598: | * @static |
| 17599: | */ |
| 17600: | public static function component($alias, $viewClass = null) |
| 17601: | { |
| 17602: | /** @var \Livewire\LivewireManager $instance */ |
| 17603: | return $instance->component($alias, $viewClass); |
| 17604: | } |
| 17605: | /** |
| 17606: | * |
| 17607: | * |
| 17608: | * @static |
| 17609: | */ |
| 17610: | public static function getAlias($class, $default = null) |
| 17611: | { |
| 17612: | /** @var \Livewire\LivewireManager $instance */ |
| 17613: | return $instance->getAlias($class, $default); |
| 17614: | } |
| 17615: | /** |
| 17616: | * |
| 17617: | * |
| 17618: | * @static |
| 17619: | */ |
| 17620: | public static function getComponentAliases() |
| 17621: | { |
| 17622: | /** @var \Livewire\LivewireManager $instance */ |
| 17623: | return $instance->getComponentAliases(); |
| 17624: | } |
| 17625: | /** |
| 17626: | * |
| 17627: | * |
| 17628: | * @static |
| 17629: | */ |
| 17630: | public static function getClass($alias) |
| 17631: | { |
| 17632: | /** @var \Livewire\LivewireManager $instance */ |
| 17633: | return $instance->getClass($alias); |
| 17634: | } |
| 17635: | /** |
| 17636: | * |
| 17637: | * |
| 17638: | * @static |
| 17639: | */ |
| 17640: | public static function getInstance($component, $id) |
| 17641: | { |
| 17642: | /** @var \Livewire\LivewireManager $instance */ |
| 17643: | return $instance->getInstance($component, $id); |
| 17644: | } |
| 17645: | /** |
| 17646: | * |
| 17647: | * |
| 17648: | * @static |
| 17649: | */ |
| 17650: | public static function mount($name, $params = []) |
| 17651: | { |
| 17652: | /** @var \Livewire\LivewireManager $instance */ |
| 17653: | return $instance->mount($name, $params); |
| 17654: | } |
| 17655: | /** |
| 17656: | * |
| 17657: | * |
| 17658: | * @static |
| 17659: | */ |
| 17660: | public static function dummyMount($id, $tagName) |
| 17661: | { |
| 17662: | /** @var \Livewire\LivewireManager $instance */ |
| 17663: | return $instance->dummyMount($id, $tagName); |
| 17664: | } |
| 17665: | /** |
| 17666: | * |
| 17667: | * |
| 17668: | * @static |
| 17669: | */ |
| 17670: | public static function test($name, $params = []) |
| 17671: | { |
| 17672: | /** @var \Livewire\LivewireManager $instance */ |
| 17673: | return $instance->test($name, $params); |
| 17674: | } |
| 17675: | /** |
| 17676: | * |
| 17677: | * |
| 17678: | * @static |
| 17679: | */ |
| 17680: | public static function visit($browser, $class, $queryString = '') |
| 17681: | { |
| 17682: | /** @var \Livewire\LivewireManager $instance */ |
| 17683: | return $instance->visit($browser, $class, $queryString); |
| 17684: | } |
| 17685: | /** |
| 17686: | * |
| 17687: | * |
| 17688: | * @static |
| 17689: | */ |
| 17690: | public static function actingAs($user, $driver = null) |
| 17691: | { |
| 17692: | /** @var \Livewire\LivewireManager $instance */ |
| 17693: | return $instance->actingAs($user, $driver); |
| 17694: | } |
| 17695: | /** |
| 17696: | * |
| 17697: | * |
| 17698: | * @static |
| 17699: | */ |
| 17700: | public static function addPersistentMiddleware($middleware) |
| 17701: | { |
| 17702: | /** @var \Livewire\LivewireManager $instance */ |
| 17703: | return $instance->addPersistentMiddleware($middleware); |
| 17704: | } |
| 17705: | /** |
| 17706: | * |
| 17707: | * |
| 17708: | * @static |
| 17709: | */ |
| 17710: | public static function setPersistentMiddleware($middleware) |
| 17711: | { |
| 17712: | /** @var \Livewire\LivewireManager $instance */ |
| 17713: | return $instance->setPersistentMiddleware($middleware); |
| 17714: | } |
| 17715: | /** |
| 17716: | * |
| 17717: | * |
| 17718: | * @static |
| 17719: | */ |
| 17720: | public static function getPersistentMiddleware() |
| 17721: | { |
| 17722: | /** @var \Livewire\LivewireManager $instance */ |
| 17723: | return $instance->getPersistentMiddleware(); |
| 17724: | } |
| 17725: | /** |
| 17726: | * |
| 17727: | * |
| 17728: | * @static |
| 17729: | */ |
| 17730: | public static function styles($options = []) |
| 17731: | { |
| 17732: | /** @var \Livewire\LivewireManager $instance */ |
| 17733: | return $instance->styles($options); |
| 17734: | } |
| 17735: | /** |
| 17736: | * |
| 17737: | * |
| 17738: | * @static |
| 17739: | */ |
| 17740: | public static function scripts($options = []) |
| 17741: | { |
| 17742: | /** @var \Livewire\LivewireManager $instance */ |
| 17743: | return $instance->scripts($options); |
| 17744: | } |
| 17745: | /** |
| 17746: | * |
| 17747: | * |
| 17748: | * @static |
| 17749: | */ |
| 17750: | public static function isLivewireRequest() |
| 17751: | { |
| 17752: | /** @var \Livewire\LivewireManager $instance */ |
| 17753: | return $instance->isLivewireRequest(); |
| 17754: | } |
| 17755: | /** |
| 17756: | * |
| 17757: | * |
| 17758: | * @static |
| 17759: | */ |
| 17760: | public static function isDefinitelyLivewireRequest() |
| 17761: | { |
| 17762: | /** @var \Livewire\LivewireManager $instance */ |
| 17763: | return $instance->isDefinitelyLivewireRequest(); |
| 17764: | } |
| 17765: | /** |
| 17766: | * |
| 17767: | * |
| 17768: | * @static |
| 17769: | */ |
| 17770: | public static function isProbablyLivewireRequest() |
| 17771: | { |
| 17772: | /** @var \Livewire\LivewireManager $instance */ |
| 17773: | return $instance->isProbablyLivewireRequest(); |
| 17774: | } |
| 17775: | /** |
| 17776: | * |
| 17777: | * |
| 17778: | * @static |
| 17779: | */ |
| 17780: | public static function originalUrl() |
| 17781: | { |
| 17782: | /** @var \Livewire\LivewireManager $instance */ |
| 17783: | return $instance->originalUrl(); |
| 17784: | } |
| 17785: | /** |
| 17786: | * |
| 17787: | * |
| 17788: | * @static |
| 17789: | */ |
| 17790: | public static function originalPath() |
| 17791: | { |
| 17792: | /** @var \Livewire\LivewireManager $instance */ |
| 17793: | return $instance->originalPath(); |
| 17794: | } |
| 17795: | /** |
| 17796: | * |
| 17797: | * |
| 17798: | * @static |
| 17799: | */ |
| 17800: | public static function originalMethod() |
| 17801: | { |
| 17802: | /** @var \Livewire\LivewireManager $instance */ |
| 17803: | return $instance->originalMethod(); |
| 17804: | } |
| 17805: | /** |
| 17806: | * |
| 17807: | * |
| 17808: | * @static |
| 17809: | */ |
| 17810: | public static function getRootElementTagName($dom) |
| 17811: | { |
| 17812: | /** @var \Livewire\LivewireManager $instance */ |
| 17813: | return $instance->getRootElementTagName($dom); |
| 17814: | } |
| 17815: | /** |
| 17816: | * |
| 17817: | * |
| 17818: | * @static |
| 17819: | */ |
| 17820: | public static function dispatch($event, ...$params) |
| 17821: | { |
| 17822: | /** @var \Livewire\LivewireManager $instance */ |
| 17823: | return $instance->dispatch($event, ...$params); |
| 17824: | } |
| 17825: | /** |
| 17826: | * |
| 17827: | * |
| 17828: | * @static |
| 17829: | */ |
| 17830: | public static function listen($event, $callback) |
| 17831: | { |
| 17832: | /** @var \Livewire\LivewireManager $instance */ |
| 17833: | return $instance->listen($event, $callback); |
| 17834: | } |
| 17835: | /** |
| 17836: | * |
| 17837: | * |
| 17838: | * @static |
| 17839: | */ |
| 17840: | public static function isOnVapor() |
| 17841: | { |
| 17842: | /** @var \Livewire\LivewireManager $instance */ |
| 17843: | return $instance->isOnVapor(); |
| 17844: | } |
| 17845: | /** |
| 17846: | * |
| 17847: | * |
| 17848: | * @static |
| 17849: | */ |
| 17850: | public static function isRunningServerless() |
| 17851: | { |
| 17852: | /** @var \Livewire\LivewireManager $instance */ |
| 17853: | return $instance->isRunningServerless(); |
| 17854: | } |
| 17855: | /** |
| 17856: | * |
| 17857: | * |
| 17858: | * @static |
| 17859: | */ |
| 17860: | public static function withQueryParams($queryParams) |
| 17861: | { |
| 17862: | /** @var \Livewire\LivewireManager $instance */ |
| 17863: | return $instance->withQueryParams($queryParams); |
| 17864: | } |
| 17865: | /** |
| 17866: | * |
| 17867: | * |
| 17868: | * @static |
| 17869: | */ |
| 17870: | public static function setBackButtonCache() |
| 17871: | { |
| 17872: | /** @var \Livewire\LivewireManager $instance */ |
| 17873: | return $instance->setBackButtonCache(); |
| 17874: | } |
| 17875: | /** |
| 17876: | * |
| 17877: | * |
| 17878: | * @static |
| 17879: | */ |
| 17880: | public static function disableBackButtonCache() |
| 17881: | { |
| 17882: | /** @var \Livewire\LivewireManager $instance */ |
| 17883: | return $instance->disableBackButtonCache(); |
| 17884: | } |
| 17885: | /** |
| 17886: | * |
| 17887: | * |
| 17888: | * @static |
| 17889: | */ |
| 17890: | public static function enableBackButtonCache() |
| 17891: | { |
| 17892: | /** @var \Livewire\LivewireManager $instance */ |
| 17893: | return $instance->enableBackButtonCache(); |
| 17894: | } |
| 17895: | /** |
| 17896: | * |
| 17897: | * |
| 17898: | * @static |
| 17899: | */ |
| 17900: | public static function shouldDisableBackButtonCache() |
| 17901: | { |
| 17902: | /** @var \Livewire\LivewireManager $instance */ |
| 17903: | return $instance->shouldDisableBackButtonCache(); |
| 17904: | } |
| 17905: | /** |
| 17906: | * |
| 17907: | * |
| 17908: | * @static |
| 17909: | */ |
| 17910: | public static function flushState() |
| 17911: | { |
| 17912: | /** @var \Livewire\LivewireManager $instance */ |
| 17913: | return $instance->flushState(); |
| 17914: | } |
| 17915: | |
| 17916: | } |
| 17917: | |
| 17918: | } |
| 17919: | |
| 17920: | namespace Lorisleiva\Actions\Facades { |
| 17921: | /** |
| 17922: | * |
| 17923: | * |
| 17924: | * @see ActionManager |
| 17925: | */ |
| 17926: | class Actions { |
| 17927: | /** |
| 17928: | * |
| 17929: | * |
| 17930: | * @static |
| 17931: | */ |
| 17932: | public static function setDesignPatterns($designPatterns) |
| 17933: | { |
| 17934: | /** @var \Lorisleiva\Actions\ActionManager $instance */ |
| 17935: | return $instance->setDesignPatterns($designPatterns); |
| 17936: | } |
| 17937: | /** |
| 17938: | * |
| 17939: | * |
| 17940: | * @static |
| 17941: | */ |
| 17942: | public static function getDesignPatterns() |
| 17943: | { |
| 17944: | /** @var \Lorisleiva\Actions\ActionManager $instance */ |
| 17945: | return $instance->getDesignPatterns(); |
| 17946: | } |
| 17947: | /** |
| 17948: | * |
| 17949: | * |
| 17950: | * @static |
| 17951: | */ |
| 17952: | public static function getDesignPatternsMatching($usedTraits) |
| 17953: | { |
| 17954: | /** @var \Lorisleiva\Actions\ActionManager $instance */ |
| 17955: | return $instance->getDesignPatternsMatching($usedTraits); |
| 17956: | } |
| 17957: | /** |
| 17958: | * |
| 17959: | * |
| 17960: | * @static |
| 17961: | */ |
| 17962: | public static function extend($abstract) |
| 17963: | { |
| 17964: | /** @var \Lorisleiva\Actions\ActionManager $instance */ |
| 17965: | return $instance->extend($abstract); |
| 17966: | } |
| 17967: | /** |
| 17968: | * |
| 17969: | * |
| 17970: | * @static |
| 17971: | */ |
| 17972: | public static function isExtending($abstract) |
| 17973: | { |
| 17974: | /** @var \Lorisleiva\Actions\ActionManager $instance */ |
| 17975: | return $instance->isExtending($abstract); |
| 17976: | } |
| 17977: | /** |
| 17978: | * |
| 17979: | * |
| 17980: | * @static |
| 17981: | */ |
| 17982: | public static function shouldExtend($abstract) |
| 17983: | { |
| 17984: | /** @var \Lorisleiva\Actions\ActionManager $instance */ |
| 17985: | return $instance->shouldExtend($abstract); |
| 17986: | } |
| 17987: | /** |
| 17988: | * |
| 17989: | * |
| 17990: | * @static |
| 17991: | */ |
| 17992: | public static function identifyAndDecorate($instance, $limit = 10) |
| 17993: | { |
| 17994: | /** @var \Lorisleiva\Actions\ActionManager $instance */ |
| 17995: | return $instance->identifyAndDecorate($instance, $limit); |
| 17996: | } |
| 17997: | /** |
| 17998: | * |
| 17999: | * |
| 18000: | * @static |
| 18001: | */ |
| 18002: | public static function identifyFromBacktrace($usedTraits, $limit = 10, $frame = null) |
| 18003: | { |
| 18004: | /** @var \Lorisleiva\Actions\ActionManager $instance */ |
| 18005: | return $instance->identifyFromBacktrace($usedTraits, $limit, $frame); |
| 18006: | } |
| 18007: | /** |
| 18008: | * |
| 18009: | * |
| 18010: | * @static |
| 18011: | */ |
| 18012: | public static function registerRoutes($paths = 'app/Actions') |
| 18013: | { |
| 18014: | /** @var \Lorisleiva\Actions\ActionManager $instance */ |
| 18015: | return $instance->registerRoutes($paths); |
| 18016: | } |
| 18017: | /** |
| 18018: | * |
| 18019: | * |
| 18020: | * @static |
| 18021: | */ |
| 18022: | public static function registerCommands($paths = 'app/Actions') |
| 18023: | { |
| 18024: | /** @var \Lorisleiva\Actions\ActionManager $instance */ |
| 18025: | return $instance->registerCommands($paths); |
| 18026: | } |
| 18027: | /** |
| 18028: | * |
| 18029: | * |
| 18030: | * @static |
| 18031: | */ |
| 18032: | public static function registerRoutesForAction($className) |
| 18033: | { |
| 18034: | /** @var \Lorisleiva\Actions\ActionManager $instance */ |
| 18035: | return $instance->registerRoutesForAction($className); |
| 18036: | } |
| 18037: | /** |
| 18038: | * |
| 18039: | * |
| 18040: | * @static |
| 18041: | */ |
| 18042: | public static function registerCommandsForAction($className) |
| 18043: | { |
| 18044: | /** @var \Lorisleiva\Actions\ActionManager $instance */ |
| 18045: | return $instance->registerCommandsForAction($className); |
| 18046: | } |
| 18047: | |
| 18048: | } |
| 18049: | |
| 18050: | } |
| 18051: | |
| 18052: | namespace Lorisleiva\Lody { |
| 18053: | /** |
| 18054: | * |
| 18055: | * |
| 18056: | * @see LodyManager |
| 18057: | */ |
| 18058: | class Lody { |
| 18059: | /** |
| 18060: | * |
| 18061: | * |
| 18062: | * @static |
| 18063: | */ |
| 18064: | public static function classes($paths, $recursive = true) |
| 18065: | { |
| 18066: | /** @var \Lorisleiva\Lody\LodyManager $instance */ |
| 18067: | return $instance->classes($paths, $recursive); |
| 18068: | } |
| 18069: | /** |
| 18070: | * |
| 18071: | * |
| 18072: | * @static |
| 18073: | */ |
| 18074: | public static function classesFromFinder($finder) |
| 18075: | { |
| 18076: | /** @var \Lorisleiva\Lody\LodyManager $instance */ |
| 18077: | return $instance->classesFromFinder($finder); |
| 18078: | } |
| 18079: | /** |
| 18080: | * |
| 18081: | * |
| 18082: | * @static |
| 18083: | */ |
| 18084: | public static function files($paths, $recursive = true, $hidden = false) |
| 18085: | { |
| 18086: | /** @var \Lorisleiva\Lody\LodyManager $instance */ |
| 18087: | return $instance->files($paths, $recursive, $hidden); |
| 18088: | } |
| 18089: | /** |
| 18090: | * |
| 18091: | * |
| 18092: | * @static |
| 18093: | */ |
| 18094: | public static function filesFromFinder($finder) |
| 18095: | { |
| 18096: | /** @var \Lorisleiva\Lody\LodyManager $instance */ |
| 18097: | return $instance->filesFromFinder($finder); |
| 18098: | } |
| 18099: | /** |
| 18100: | * |
| 18101: | * |
| 18102: | * @static |
| 18103: | */ |
| 18104: | public static function resolvePathUsing($callback) |
| 18105: | { |
| 18106: | /** @var \Lorisleiva\Lody\LodyManager $instance */ |
| 18107: | return $instance->resolvePathUsing($callback); |
| 18108: | } |
| 18109: | /** |
| 18110: | * |
| 18111: | * |
| 18112: | * @static |
| 18113: | */ |
| 18114: | public static function resolvePath($path) |
| 18115: | { |
| 18116: | /** @var \Lorisleiva\Lody\LodyManager $instance */ |
| 18117: | return $instance->resolvePath($path); |
| 18118: | } |
| 18119: | /** |
| 18120: | * |
| 18121: | * |
| 18122: | * @static |
| 18123: | */ |
| 18124: | public static function resolveClassnameUsing($callback) |
| 18125: | { |
| 18126: | /** @var \Lorisleiva\Lody\LodyManager $instance */ |
| 18127: | return $instance->resolveClassnameUsing($callback); |
| 18128: | } |
| 18129: | /** |
| 18130: | * |
| 18131: | * |
| 18132: | * @static |
| 18133: | */ |
| 18134: | public static function resolveClassname($file) |
| 18135: | { |
| 18136: | /** @var \Lorisleiva\Lody\LodyManager $instance */ |
| 18137: | return $instance->resolveClassname($file); |
| 18138: | } |
| 18139: | /** |
| 18140: | * |
| 18141: | * |
| 18142: | * @static |
| 18143: | */ |
| 18144: | public static function setBasePath($basePath) |
| 18145: | { |
| 18146: | /** @var \Lorisleiva\Lody\LodyManager $instance */ |
| 18147: | return $instance->setBasePath($basePath); |
| 18148: | } |
| 18149: | /** |
| 18150: | * |
| 18151: | * |
| 18152: | * @static |
| 18153: | */ |
| 18154: | public static function getBasePath($path = '') |
| 18155: | { |
| 18156: | /** @var \Lorisleiva\Lody\LodyManager $instance */ |
| 18157: | return $instance->getBasePath($path); |
| 18158: | } |
| 18159: | /** |
| 18160: | * |
| 18161: | * |
| 18162: | * @static |
| 18163: | */ |
| 18164: | public static function setAutoloadPath($autoloadPath) |
| 18165: | { |
| 18166: | /** @var \Lorisleiva\Lody\LodyManager $instance */ |
| 18167: | return $instance->setAutoloadPath($autoloadPath); |
| 18168: | } |
| 18169: | /** |
| 18170: | * |
| 18171: | * |
| 18172: | * @static |
| 18173: | */ |
| 18174: | public static function getAutoloadPath() |
| 18175: | { |
| 18176: | /** @var \Lorisleiva\Lody\LodyManager $instance */ |
| 18177: | return $instance->getAutoloadPath(); |
| 18178: | } |
| 18179: | |
| 18180: | } |
| 18181: | |
| 18182: | } |
| 18183: | |
| 18184: | namespace BeyondCode\ServerTiming\Facades { |
| 18185: | /** |
| 18186: | * |
| 18187: | * |
| 18188: | */ |
| 18189: | class ServerTiming { |
| 18190: | /** |
| 18191: | * |
| 18192: | * |
| 18193: | * @static |
| 18194: | */ |
| 18195: | public static function addMetric($metric) |
| 18196: | { |
| 18197: | /** @var \BeyondCode\ServerTiming\ServerTiming $instance */ |
| 18198: | return $instance->addMetric($metric); |
| 18199: | } |
| 18200: | /** |
| 18201: | * |
| 18202: | * |
| 18203: | * @static |
| 18204: | */ |
| 18205: | public static function addMessage($message) |
| 18206: | { |
| 18207: | /** @var \BeyondCode\ServerTiming\ServerTiming $instance */ |
| 18208: | return $instance->addMessage($message); |
| 18209: | } |
| 18210: | /** |
| 18211: | * |
| 18212: | * |
| 18213: | * @static |
| 18214: | */ |
| 18215: | public static function hasStartedEvent($key) |
| 18216: | { |
| 18217: | /** @var \BeyondCode\ServerTiming\ServerTiming $instance */ |
| 18218: | return $instance->hasStartedEvent($key); |
| 18219: | } |
| 18220: | /** |
| 18221: | * |
| 18222: | * |
| 18223: | * @static |
| 18224: | */ |
| 18225: | public static function measure($key) |
| 18226: | { |
| 18227: | /** @var \BeyondCode\ServerTiming\ServerTiming $instance */ |
| 18228: | return $instance->measure($key); |
| 18229: | } |
| 18230: | /** |
| 18231: | * |
| 18232: | * |
| 18233: | * @static |
| 18234: | */ |
| 18235: | public static function start($key) |
| 18236: | { |
| 18237: | /** @var \BeyondCode\ServerTiming\ServerTiming $instance */ |
| 18238: | return $instance->start($key); |
| 18239: | } |
| 18240: | /** |
| 18241: | * |
| 18242: | * |
| 18243: | * @static |
| 18244: | */ |
| 18245: | public static function stop($key) |
| 18246: | { |
| 18247: | /** @var \BeyondCode\ServerTiming\ServerTiming $instance */ |
| 18248: | return $instance->stop($key); |
| 18249: | } |
| 18250: | /** |
| 18251: | * |
| 18252: | * |
| 18253: | * @static |
| 18254: | */ |
| 18255: | public static function stopAllUnfinishedEvents() |
| 18256: | { |
| 18257: | /** @var \BeyondCode\ServerTiming\ServerTiming $instance */ |
| 18258: | return $instance->stopAllUnfinishedEvents(); |
| 18259: | } |
| 18260: | /** |
| 18261: | * |
| 18262: | * |
| 18263: | * @static |
| 18264: | */ |
| 18265: | public static function setDuration($key, $duration) |
| 18266: | { |
| 18267: | /** @var \BeyondCode\ServerTiming\ServerTiming $instance */ |
| 18268: | return $instance->setDuration($key, $duration); |
| 18269: | } |
| 18270: | /** |
| 18271: | * |
| 18272: | * |
| 18273: | * @static |
| 18274: | */ |
| 18275: | public static function getDuration($key) |
| 18276: | { |
| 18277: | /** @var \BeyondCode\ServerTiming\ServerTiming $instance */ |
| 18278: | return $instance->getDuration($key); |
| 18279: | } |
| 18280: | /** |
| 18281: | * |
| 18282: | * |
| 18283: | * @return \BeyondCode\ServerTiming\array<string, int|float|null> |
| 18284: | * @static |
| 18285: | */ |
| 18286: | public static function events() |
| 18287: | { |
| 18288: | /** @var \BeyondCode\ServerTiming\ServerTiming $instance */ |
| 18289: | return $instance->events(); |
| 18290: | } |
| 18291: | /** |
| 18292: | * |
| 18293: | * |
| 18294: | * @static |
| 18295: | */ |
| 18296: | public static function reset() |
| 18297: | { |
| 18298: | /** @var \BeyondCode\ServerTiming\ServerTiming $instance */ |
| 18299: | return $instance->reset(); |
| 18300: | } |
| 18301: | |
| 18302: | } |
| 18303: | |
| 18304: | } |
| 18305: | |
| 18306: | namespace Spatie\LaravelIgnition\Facades { |
| 18307: | /** |
| 18308: | * |
| 18309: | * |
| 18310: | * @see \Spatie\FlareClient\Flare |
| 18311: | */ |
| 18312: | class Flare { |
| 18313: | /** |
| 18314: | * |
| 18315: | * |
| 18316: | * @static |
| 18317: | */ |
| 18318: | public static function make($apiKey = null, $contextDetector = null) |
| 18319: | { |
| 18320: | return \Spatie\FlareClient\Flare::make($apiKey, $contextDetector); |
| 18321: | } |
| 18322: | /** |
| 18323: | * |
| 18324: | * |
| 18325: | * @static |
| 18326: | */ |
| 18327: | public static function setApiToken($apiToken) |
| 18328: | { |
| 18329: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18330: | return $instance->setApiToken($apiToken); |
| 18331: | } |
| 18332: | /** |
| 18333: | * |
| 18334: | * |
| 18335: | * @static |
| 18336: | */ |
| 18337: | public static function apiTokenSet() |
| 18338: | { |
| 18339: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18340: | return $instance->apiTokenSet(); |
| 18341: | } |
| 18342: | /** |
| 18343: | * |
| 18344: | * |
| 18345: | * @static |
| 18346: | */ |
| 18347: | public static function setBaseUrl($baseUrl) |
| 18348: | { |
| 18349: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18350: | return $instance->setBaseUrl($baseUrl); |
| 18351: | } |
| 18352: | /** |
| 18353: | * |
| 18354: | * |
| 18355: | * @static |
| 18356: | */ |
| 18357: | public static function setStage($stage) |
| 18358: | { |
| 18359: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18360: | return $instance->setStage($stage); |
| 18361: | } |
| 18362: | /** |
| 18363: | * |
| 18364: | * |
| 18365: | * @static |
| 18366: | */ |
| 18367: | public static function sendReportsImmediately() |
| 18368: | { |
| 18369: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18370: | return $instance->sendReportsImmediately(); |
| 18371: | } |
| 18372: | /** |
| 18373: | * |
| 18374: | * |
| 18375: | * @static |
| 18376: | */ |
| 18377: | public static function determineVersionUsing($determineVersionCallable) |
| 18378: | { |
| 18379: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18380: | return $instance->determineVersionUsing($determineVersionCallable); |
| 18381: | } |
| 18382: | /** |
| 18383: | * |
| 18384: | * |
| 18385: | * @static |
| 18386: | */ |
| 18387: | public static function reportErrorLevels($reportErrorLevels) |
| 18388: | { |
| 18389: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18390: | return $instance->reportErrorLevels($reportErrorLevels); |
| 18391: | } |
| 18392: | /** |
| 18393: | * |
| 18394: | * |
| 18395: | * @static |
| 18396: | */ |
| 18397: | public static function filterExceptionsUsing($filterExceptionsCallable) |
| 18398: | { |
| 18399: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18400: | return $instance->filterExceptionsUsing($filterExceptionsCallable); |
| 18401: | } |
| 18402: | /** |
| 18403: | * |
| 18404: | * |
| 18405: | * @static |
| 18406: | */ |
| 18407: | public static function version() |
| 18408: | { |
| 18409: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18410: | return $instance->version(); |
| 18411: | } |
| 18412: | /** |
| 18413: | * |
| 18414: | * |
| 18415: | * @return \Spatie\FlareClient\array<int, FlareMiddleware|class-string<FlareMiddleware>> |
| 18416: | * @static |
| 18417: | */ |
| 18418: | public static function getMiddleware() |
| 18419: | { |
| 18420: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18421: | return $instance->getMiddleware(); |
| 18422: | } |
| 18423: | /** |
| 18424: | * |
| 18425: | * |
| 18426: | * @static |
| 18427: | */ |
| 18428: | public static function setContextProviderDetector($contextDetector) |
| 18429: | { |
| 18430: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18431: | return $instance->setContextProviderDetector($contextDetector); |
| 18432: | } |
| 18433: | /** |
| 18434: | * |
| 18435: | * |
| 18436: | * @static |
| 18437: | */ |
| 18438: | public static function setContainer($container) |
| 18439: | { |
| 18440: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18441: | return $instance->setContainer($container); |
| 18442: | } |
| 18443: | /** |
| 18444: | * |
| 18445: | * |
| 18446: | * @static |
| 18447: | */ |
| 18448: | public static function registerFlareHandlers() |
| 18449: | { |
| 18450: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18451: | return $instance->registerFlareHandlers(); |
| 18452: | } |
| 18453: | /** |
| 18454: | * |
| 18455: | * |
| 18456: | * @static |
| 18457: | */ |
| 18458: | public static function registerExceptionHandler() |
| 18459: | { |
| 18460: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18461: | return $instance->registerExceptionHandler(); |
| 18462: | } |
| 18463: | /** |
| 18464: | * |
| 18465: | * |
| 18466: | * @static |
| 18467: | */ |
| 18468: | public static function registerErrorHandler() |
| 18469: | { |
| 18470: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18471: | return $instance->registerErrorHandler(); |
| 18472: | } |
| 18473: | /** |
| 18474: | * |
| 18475: | * |
| 18476: | * @param \Spatie\FlareClient\FlareMiddleware\FlareMiddleware|\Spatie\FlareClient\array<FlareMiddleware>|\Spatie\FlareClient\class-string<FlareMiddleware> $middleware |
| 18477: | * @return \Spatie\FlareClient\Flare |
| 18478: | * @static |
| 18479: | */ |
| 18480: | public static function registerMiddleware($middleware) |
| 18481: | { |
| 18482: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18483: | return $instance->registerMiddleware($middleware); |
| 18484: | } |
| 18485: | /** |
| 18486: | * |
| 18487: | * |
| 18488: | * @return \Spatie\FlareClient\array<int,FlareMiddleware|\Spatie\FlareClient\class-string<FlareMiddleware>> |
| 18489: | * @static |
| 18490: | */ |
| 18491: | public static function getMiddlewares() |
| 18492: | { |
| 18493: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18494: | return $instance->getMiddlewares(); |
| 18495: | } |
| 18496: | /** |
| 18497: | * |
| 18498: | * |
| 18499: | * @param string $name |
| 18500: | * @param string $messageLevel |
| 18501: | * @param \Spatie\FlareClient\array<int, mixed> $metaData |
| 18502: | * @return \Spatie\FlareClient\Flare |
| 18503: | * @static |
| 18504: | */ |
| 18505: | public static function glow($name, $messageLevel = 'info', $metaData = []) |
| 18506: | { |
| 18507: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18508: | return $instance->glow($name, $messageLevel, $metaData); |
| 18509: | } |
| 18510: | /** |
| 18511: | * |
| 18512: | * |
| 18513: | * @static |
| 18514: | */ |
| 18515: | public static function handleException($throwable) |
| 18516: | { |
| 18517: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18518: | return $instance->handleException($throwable); |
| 18519: | } |
| 18520: | /** |
| 18521: | * |
| 18522: | * |
| 18523: | * @return mixed |
| 18524: | * @static |
| 18525: | */ |
| 18526: | public static function handleError($code, $message, $file = '', $line = 0) |
| 18527: | { |
| 18528: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18529: | return $instance->handleError($code, $message, $file, $line); |
| 18530: | } |
| 18531: | /** |
| 18532: | * |
| 18533: | * |
| 18534: | * @static |
| 18535: | */ |
| 18536: | public static function applicationPath($applicationPath) |
| 18537: | { |
| 18538: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18539: | return $instance->applicationPath($applicationPath); |
| 18540: | } |
| 18541: | /** |
| 18542: | * |
| 18543: | * |
| 18544: | * @static |
| 18545: | */ |
| 18546: | public static function report($throwable, $callback = null, $report = null) |
| 18547: | { |
| 18548: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18549: | return $instance->report($throwable, $callback, $report); |
| 18550: | } |
| 18551: | /** |
| 18552: | * |
| 18553: | * |
| 18554: | * @static |
| 18555: | */ |
| 18556: | public static function reportMessage($message, $logLevel, $callback = null) |
| 18557: | { |
| 18558: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18559: | return $instance->reportMessage($message, $logLevel, $callback); |
| 18560: | } |
| 18561: | /** |
| 18562: | * |
| 18563: | * |
| 18564: | * @static |
| 18565: | */ |
| 18566: | public static function sendTestReport($throwable) |
| 18567: | { |
| 18568: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18569: | return $instance->sendTestReport($throwable); |
| 18570: | } |
| 18571: | /** |
| 18572: | * |
| 18573: | * |
| 18574: | * @static |
| 18575: | */ |
| 18576: | public static function reset() |
| 18577: | { |
| 18578: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18579: | return $instance->reset(); |
| 18580: | } |
| 18581: | /** |
| 18582: | * |
| 18583: | * |
| 18584: | * @static |
| 18585: | */ |
| 18586: | public static function anonymizeIp() |
| 18587: | { |
| 18588: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18589: | return $instance->anonymizeIp(); |
| 18590: | } |
| 18591: | /** |
| 18592: | * |
| 18593: | * |
| 18594: | * @param \Spatie\FlareClient\array<int, string> $fieldNames |
| 18595: | * @return \Spatie\FlareClient\Flare |
| 18596: | * @static |
| 18597: | */ |
| 18598: | public static function censorRequestBodyFields($fieldNames) |
| 18599: | { |
| 18600: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18601: | return $instance->censorRequestBodyFields($fieldNames); |
| 18602: | } |
| 18603: | /** |
| 18604: | * |
| 18605: | * |
| 18606: | * @static |
| 18607: | */ |
| 18608: | public static function createReport($throwable) |
| 18609: | { |
| 18610: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18611: | return $instance->createReport($throwable); |
| 18612: | } |
| 18613: | /** |
| 18614: | * |
| 18615: | * |
| 18616: | * @static |
| 18617: | */ |
| 18618: | public static function createReportFromMessage($message, $logLevel) |
| 18619: | { |
| 18620: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18621: | return $instance->createReportFromMessage($message, $logLevel); |
| 18622: | } |
| 18623: | /** |
| 18624: | * |
| 18625: | * |
| 18626: | * @static |
| 18627: | */ |
| 18628: | public static function stage($stage) |
| 18629: | { |
| 18630: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18631: | return $instance->stage($stage); |
| 18632: | } |
| 18633: | /** |
| 18634: | * |
| 18635: | * |
| 18636: | * @static |
| 18637: | */ |
| 18638: | public static function messageLevel($messageLevel) |
| 18639: | { |
| 18640: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18641: | return $instance->messageLevel($messageLevel); |
| 18642: | } |
| 18643: | /** |
| 18644: | * |
| 18645: | * |
| 18646: | * @param string $groupName |
| 18647: | * @param mixed $default |
| 18648: | * @return \Spatie\FlareClient\array<int, mixed> |
| 18649: | * @static |
| 18650: | */ |
| 18651: | public static function getGroup($groupName = 'context', $default = []) |
| 18652: | { |
| 18653: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18654: | return $instance->getGroup($groupName, $default); |
| 18655: | } |
| 18656: | /** |
| 18657: | * |
| 18658: | * |
| 18659: | * @static |
| 18660: | */ |
| 18661: | public static function context($key, $value) |
| 18662: | { |
| 18663: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18664: | return $instance->context($key, $value); |
| 18665: | } |
| 18666: | /** |
| 18667: | * |
| 18668: | * |
| 18669: | * @param string $groupName |
| 18670: | * @param \Spatie\FlareClient\array<string, mixed> $properties |
| 18671: | * @return \Spatie\FlareClient\Flare |
| 18672: | * @static |
| 18673: | */ |
| 18674: | public static function group($groupName, $properties) |
| 18675: | { |
| 18676: | /** @var \Spatie\FlareClient\Flare $instance */ |
| 18677: | return $instance->group($groupName, $properties); |
| 18678: | } |
| 18679: | |
| 18680: | } |
| 18681: | |
| 18682: | } |
| 18683: | |
| 18684: | namespace Illuminate\Filesystem { |
| 18685: | /** |
| 18686: | * |
| 18687: | * |
| 18688: | */ |
| 18689: | class Filesystem { |
| 18690: | /** |
| 18691: | * |
| 18692: | * |
| 18693: | * @see \Blueprint\FileMixins::stub() |
| 18694: | * @param mixed $path |
| 18695: | * @static |
| 18696: | */ |
| 18697: | public static function stub($path) |
| 18698: | { |
| 18699: | return \Illuminate\Filesystem\Filesystem::stub($path); |
| 18700: | } |
| 18701: | |
| 18702: | } |
| 18703: | |
| 18704: | } |
| 18705: | |
| 18706: | namespace Illuminate\Http { |
| 18707: | /** |
| 18708: | * |
| 18709: | * |
| 18710: | */ |
| 18711: | class Request { |
| 18712: | /** |
| 18713: | * |
| 18714: | * |
| 18715: | * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation() |
| 18716: | * @param array $rules |
| 18717: | * @param mixed $params |
| 18718: | * @static |
| 18719: | */ |
| 18720: | public static function validate($rules, ...$params) |
| 18721: | { |
| 18722: | return \Illuminate\Http\Request::validate($rules, ...$params); |
| 18723: | } |
| 18724: | /** |
| 18725: | * |
| 18726: | * |
| 18727: | * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation() |
| 18728: | * @param string $errorBag |
| 18729: | * @param array $rules |
| 18730: | * @param mixed $params |
| 18731: | * @static |
| 18732: | */ |
| 18733: | public static function validateWithBag($errorBag, $rules, ...$params) |
| 18734: | { |
| 18735: | return \Illuminate\Http\Request::validateWithBag($errorBag, $rules, ...$params); |
| 18736: | } |
| 18737: | /** |
| 18738: | * |
| 18739: | * |
| 18740: | * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation() |
| 18741: | * @param mixed $absolute |
| 18742: | * @static |
| 18743: | */ |
| 18744: | public static function hasValidSignature($absolute = true) |
| 18745: | { |
| 18746: | return \Illuminate\Http\Request::hasValidSignature($absolute); |
| 18747: | } |
| 18748: | /** |
| 18749: | * |
| 18750: | * |
| 18751: | * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation() |
| 18752: | * @static |
| 18753: | */ |
| 18754: | public static function hasValidRelativeSignature() |
| 18755: | { |
| 18756: | return \Illuminate\Http\Request::hasValidRelativeSignature(); |
| 18757: | } |
| 18758: | /** |
| 18759: | * |
| 18760: | * |
| 18761: | * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation() |
| 18762: | * @param mixed $ignoreQuery |
| 18763: | * @param mixed $absolute |
| 18764: | * @static |
| 18765: | */ |
| 18766: | public static function hasValidSignatureWhileIgnoring($ignoreQuery = [], $absolute = true) |
| 18767: | { |
| 18768: | return \Illuminate\Http\Request::hasValidSignatureWhileIgnoring($ignoreQuery, $absolute); |
| 18769: | } |
| 18770: | |
| 18771: | } |
| 18772: | /** |
| 18773: | * |
| 18774: | * |
| 18775: | */ |
| 18776: | class RedirectResponse { |
| 18777: | /** |
| 18778: | * |
| 18779: | * |
| 18780: | * @see \Laravel\Jetstream\JetstreamServiceProvider::boot() |
| 18781: | * @param mixed $message |
| 18782: | * @static |
| 18783: | */ |
| 18784: | public static function banner($message) |
| 18785: | { |
| 18786: | return \Illuminate\Http\RedirectResponse::banner($message); |
| 18787: | } |
| 18788: | /** |
| 18789: | * |
| 18790: | * |
| 18791: | * @see \Laravel\Jetstream\JetstreamServiceProvider::boot() |
| 18792: | * @param mixed $message |
| 18793: | * @static |
| 18794: | */ |
| 18795: | public static function dangerBanner($message) |
| 18796: | { |
| 18797: | return \Illuminate\Http\RedirectResponse::dangerBanner($message); |
| 18798: | } |
| 18799: | |
| 18800: | } |
| 18801: | |
| 18802: | } |
| 18803: | |
| 18804: | namespace Livewire\Testing { |
| 18805: | /** |
| 18806: | * |
| 18807: | * |
| 18808: | * @mixin \Illuminate\Testing\TestResponse |
| 18809: | */ |
| 18810: | class TestableLivewire { |
| 18811: | /** |
| 18812: | * |
| 18813: | * |
| 18814: | * @see \Filament\Support\Testing\TestsActions::parseActionName() |
| 18815: | * @param string $name |
| 18816: | * @return string |
| 18817: | * @static |
| 18818: | */ |
| 18819: | public static function parseActionName($name) |
| 18820: | { |
| 18821: | return \Livewire\Testing\TestableLivewire::parseActionName($name); |
| 18822: | } |
| 18823: | /** |
| 18824: | * |
| 18825: | * |
| 18826: | * @see \Filament\Testing\TestsPages::fillForm() |
| 18827: | * @param array $state |
| 18828: | * @return static |
| 18829: | * @static |
| 18830: | */ |
| 18831: | public static function fillForm($state = []) |
| 18832: | { |
| 18833: | return \Livewire\Testing\TestableLivewire::fillForm($state); |
| 18834: | } |
| 18835: | /** |
| 18836: | * |
| 18837: | * |
| 18838: | * @see \Filament\Testing\TestsPages::assertFormSet() |
| 18839: | * @param array $state |
| 18840: | * @return static |
| 18841: | * @static |
| 18842: | */ |
| 18843: | public static function assertFormSet($state) |
| 18844: | { |
| 18845: | return \Livewire\Testing\TestableLivewire::assertFormSet($state); |
| 18846: | } |
| 18847: | /** |
| 18848: | * |
| 18849: | * |
| 18850: | * @see \Filament\Testing\TestsPages::assertHasFormErrors() |
| 18851: | * @param array $keys |
| 18852: | * @return static |
| 18853: | * @static |
| 18854: | */ |
| 18855: | public static function assertHasFormErrors($keys = []) |
| 18856: | { |
| 18857: | return \Livewire\Testing\TestableLivewire::assertHasFormErrors($keys); |
| 18858: | } |
| 18859: | /** |
| 18860: | * |
| 18861: | * |
| 18862: | * @see \Filament\Testing\TestsPages::assertHasNoFormErrors() |
| 18863: | * @param array $keys |
| 18864: | * @return static |
| 18865: | * @static |
| 18866: | */ |
| 18867: | public static function assertHasNoFormErrors($keys = []) |
| 18868: | { |
| 18869: | return \Livewire\Testing\TestableLivewire::assertHasNoFormErrors($keys); |
| 18870: | } |
| 18871: | /** |
| 18872: | * |
| 18873: | * |
| 18874: | * @see \Filament\Testing\TestsPages::callPageAction() |
| 18875: | * @param string $name |
| 18876: | * @param array $data |
| 18877: | * @param array $arguments |
| 18878: | * @return static |
| 18879: | * @static |
| 18880: | */ |
| 18881: | public static function callPageAction($name, $data = [], $arguments = []) |
| 18882: | { |
| 18883: | return \Livewire\Testing\TestableLivewire::callPageAction($name, $data, $arguments); |
| 18884: | } |
| 18885: | /** |
| 18886: | * |
| 18887: | * |
| 18888: | * @see \Filament\Testing\TestsPages::assertPageActionExists() |
| 18889: | * @param string $name |
| 18890: | * @return static |
| 18891: | * @static |
| 18892: | */ |
| 18893: | public static function assertPageActionExists($name) |
| 18894: | { |
| 18895: | return \Livewire\Testing\TestableLivewire::assertPageActionExists($name); |
| 18896: | } |
| 18897: | /** |
| 18898: | * |
| 18899: | * |
| 18900: | * @see \Filament\Testing\TestsPages::assertPageActionHeld() |
| 18901: | * @param string $name |
| 18902: | * @return static |
| 18903: | * @static |
| 18904: | */ |
| 18905: | public static function assertPageActionHeld($name) |
| 18906: | { |
| 18907: | return \Livewire\Testing\TestableLivewire::assertPageActionHeld($name); |
| 18908: | } |
| 18909: | /** |
| 18910: | * |
| 18911: | * |
| 18912: | * @see \Filament\Testing\TestsPages::assertHasPageActionErrors() |
| 18913: | * @param array $keys |
| 18914: | * @return static |
| 18915: | * @static |
| 18916: | */ |
| 18917: | public static function assertHasPageActionErrors($keys = []) |
| 18918: | { |
| 18919: | return \Livewire\Testing\TestableLivewire::assertHasPageActionErrors($keys); |
| 18920: | } |
| 18921: | /** |
| 18922: | * |
| 18923: | * |
| 18924: | * @see \Filament\Testing\TestsPages::assertHasNoPageActionErrors() |
| 18925: | * @param array $keys |
| 18926: | * @return static |
| 18927: | * @static |
| 18928: | */ |
| 18929: | public static function assertHasNoPageActionErrors($keys = []) |
| 18930: | { |
| 18931: | return \Livewire\Testing\TestableLivewire::assertHasNoPageActionErrors($keys); |
| 18932: | } |
| 18933: | /** |
| 18934: | * |
| 18935: | * |
| 18936: | * @see \Filament\Tables\Testing\TestsActions::callTableAction() |
| 18937: | * @param string $name |
| 18938: | * @param mixed $record |
| 18939: | * @param array $data |
| 18940: | * @param array $arguments |
| 18941: | * @return static |
| 18942: | * @static |
| 18943: | */ |
| 18944: | public static function callTableAction($name, $record = null, $data = [], $arguments = []) |
| 18945: | { |
| 18946: | return \Livewire\Testing\TestableLivewire::callTableAction($name, $record, $data, $arguments); |
| 18947: | } |
| 18948: | /** |
| 18949: | * |
| 18950: | * |
| 18951: | * @see \Filament\Tables\Testing\TestsActions::assertTableActionExists() |
| 18952: | * @param string $name |
| 18953: | * @return static |
| 18954: | * @static |
| 18955: | */ |
| 18956: | public static function assertTableActionExists($name) |
| 18957: | { |
| 18958: | return \Livewire\Testing\TestableLivewire::assertTableActionExists($name); |
| 18959: | } |
| 18960: | /** |
| 18961: | * |
| 18962: | * |
| 18963: | * @see \Filament\Tables\Testing\TestsActions::assertTableActionHeld() |
| 18964: | * @param string $name |
| 18965: | * @return static |
| 18966: | * @static |
| 18967: | */ |
| 18968: | public static function assertTableActionHeld($name) |
| 18969: | { |
| 18970: | return \Livewire\Testing\TestableLivewire::assertTableActionHeld($name); |
| 18971: | } |
| 18972: | /** |
| 18973: | * |
| 18974: | * |
| 18975: | * @see \Filament\Tables\Testing\TestsActions::assertHasTableActionErrors() |
| 18976: | * @param array $keys |
| 18977: | * @return static |
| 18978: | * @static |
| 18979: | */ |
| 18980: | public static function assertHasTableActionErrors($keys = []) |
| 18981: | { |
| 18982: | return \Livewire\Testing\TestableLivewire::assertHasTableActionErrors($keys); |
| 18983: | } |
| 18984: | /** |
| 18985: | * |
| 18986: | * |
| 18987: | * @see \Filament\Tables\Testing\TestsActions::assertHasNoTableActionErrors() |
| 18988: | * @param array $keys |
| 18989: | * @return static |
| 18990: | * @static |
| 18991: | */ |
| 18992: | public static function assertHasNoTableActionErrors($keys = []) |
| 18993: | { |
| 18994: | return \Livewire\Testing\TestableLivewire::assertHasNoTableActionErrors($keys); |
| 18995: | } |
| 18996: | /** |
| 18997: | * |
| 18998: | * |
| 18999: | * @see \Filament\Tables\Testing\TestsActions::callTableBulkAction() |
| 19000: | * @param string $name |
| 19001: | * @param \Illuminate\Support\Collection|array $records |
| 19002: | * @param array $data |
| 19003: | * @param array $arguments |
| 19004: | * @return static |
| 19005: | * @static |
| 19006: | */ |
| 19007: | public static function callTableBulkAction($name, $records, $data = [], $arguments = []) |
| 19008: | { |
| 19009: | return \Livewire\Testing\TestableLivewire::callTableBulkAction($name, $records, $data, $arguments); |
| 19010: | } |
| 19011: | /** |
| 19012: | * |
| 19013: | * |
| 19014: | * @see \Filament\Tables\Testing\TestsActions::assertTableBulkActionExists() |
| 19015: | * @param string $name |
| 19016: | * @return static |
| 19017: | * @static |
| 19018: | */ |
| 19019: | public static function assertTableBulkActionExists($name) |
| 19020: | { |
| 19021: | return \Livewire\Testing\TestableLivewire::assertTableBulkActionExists($name); |
| 19022: | } |
| 19023: | /** |
| 19024: | * |
| 19025: | * |
| 19026: | * @see \Filament\Tables\Testing\TestsActions::assertTableBulkActionHeld() |
| 19027: | * @param string $name |
| 19028: | * @return static |
| 19029: | * @static |
| 19030: | */ |
| 19031: | public static function assertTableBulkActionHeld($name) |
| 19032: | { |
| 19033: | return \Livewire\Testing\TestableLivewire::assertTableBulkActionHeld($name); |
| 19034: | } |
| 19035: | /** |
| 19036: | * |
| 19037: | * |
| 19038: | * @see \Filament\Tables\Testing\TestsActions::assertHasTableBulkActionErrors() |
| 19039: | * @param array $keys |
| 19040: | * @return static |
| 19041: | * @static |
| 19042: | */ |
| 19043: | public static function assertHasTableBulkActionErrors($keys = []) |
| 19044: | { |
| 19045: | return \Livewire\Testing\TestableLivewire::assertHasTableBulkActionErrors($keys); |
| 19046: | } |
| 19047: | /** |
| 19048: | * |
| 19049: | * |
| 19050: | * @see \Filament\Tables\Testing\TestsActions::assertHasNoTableBulkActionErrors() |
| 19051: | * @param array $keys |
| 19052: | * @return static |
| 19053: | * @static |
| 19054: | */ |
| 19055: | public static function assertHasNoTableBulkActionErrors($keys = []) |
| 19056: | { |
| 19057: | return \Livewire\Testing\TestableLivewire::assertHasNoTableBulkActionErrors($keys); |
| 19058: | } |
| 19059: | /** |
| 19060: | * |
| 19061: | * |
| 19062: | * @see \Filament\Tables\Testing\TestsColumns::assertCanRenderTableColumn() |
| 19063: | * @param string $name |
| 19064: | * @return static |
| 19065: | * @static |
| 19066: | */ |
| 19067: | public static function assertCanRenderTableColumn($name) |
| 19068: | { |
| 19069: | return \Livewire\Testing\TestableLivewire::assertCanRenderTableColumn($name); |
| 19070: | } |
| 19071: | /** |
| 19072: | * |
| 19073: | * |
| 19074: | * @see \Filament\Tables\Testing\TestsColumns::assertTableColumnExists() |
| 19075: | * @param string $name |
| 19076: | * @return static |
| 19077: | * @static |
| 19078: | */ |
| 19079: | public static function assertTableColumnExists($name) |
| 19080: | { |
| 19081: | return \Livewire\Testing\TestableLivewire::assertTableColumnExists($name); |
| 19082: | } |
| 19083: | /** |
| 19084: | * |
| 19085: | * |
| 19086: | * @see \Filament\Tables\Testing\TestsColumns::sortTable() |
| 19087: | * @param string|null $name |
| 19088: | * @param string|null $direction |
| 19089: | * @return static |
| 19090: | * @static |
| 19091: | */ |
| 19092: | public static function sortTable($name = null, $direction = null) |
| 19093: | { |
| 19094: | return \Livewire\Testing\TestableLivewire::sortTable($name, $direction); |
| 19095: | } |
| 19096: | /** |
| 19097: | * |
| 19098: | * |
| 19099: | * @see \Filament\Tables\Testing\TestsColumns::searchTable() |
| 19100: | * @param string|null $search |
| 19101: | * @return static |
| 19102: | * @static |
| 19103: | */ |
| 19104: | public static function searchTable($search = null) |
| 19105: | { |
| 19106: | return \Livewire\Testing\TestableLivewire::searchTable($search); |
| 19107: | } |
| 19108: | /** |
| 19109: | * |
| 19110: | * |
| 19111: | * @see \Filament\Tables\Testing\TestsFilters::filterTable() |
| 19112: | * @param string $name |
| 19113: | * @param mixed $data |
| 19114: | * @return static |
| 19115: | * @static |
| 19116: | */ |
| 19117: | public static function filterTable($name, $data = null) |
| 19118: | { |
| 19119: | return \Livewire\Testing\TestableLivewire::filterTable($name, $data); |
| 19120: | } |
| 19121: | /** |
| 19122: | * |
| 19123: | * |
| 19124: | * @see \Filament\Tables\Testing\TestsFilters::resetTableFilters() |
| 19125: | * @return static |
| 19126: | * @static |
| 19127: | */ |
| 19128: | public static function resetTableFilters() |
| 19129: | { |
| 19130: | return \Livewire\Testing\TestableLivewire::resetTableFilters(); |
| 19131: | } |
| 19132: | /** |
| 19133: | * |
| 19134: | * |
| 19135: | * @see \Filament\Tables\Testing\TestsFilters::assertTableFilterExists() |
| 19136: | * @param string $name |
| 19137: | * @return static |
| 19138: | * @static |
| 19139: | */ |
| 19140: | public static function assertTableFilterExists($name) |
| 19141: | { |
| 19142: | return \Livewire\Testing\TestableLivewire::assertTableFilterExists($name); |
| 19143: | } |
| 19144: | /** |
| 19145: | * |
| 19146: | * |
| 19147: | * @see \Filament\Tables\Testing\TestsFilters::parseFilterName() |
| 19148: | * @param string $name |
| 19149: | * @return string |
| 19150: | * @static |
| 19151: | */ |
| 19152: | public static function parseFilterName($name) |
| 19153: | { |
| 19154: | return \Livewire\Testing\TestableLivewire::parseFilterName($name); |
| 19155: | } |
| 19156: | /** |
| 19157: | * |
| 19158: | * |
| 19159: | * @see \Filament\Tables\Testing\TestsRecords::assertCanSeeTableRecords() |
| 19160: | * @param \Illuminate\Support\Collection|array $records |
| 19161: | * @param bool $inOrder |
| 19162: | * @return static |
| 19163: | * @static |
| 19164: | */ |
| 19165: | public static function assertCanSeeTableRecords($records, $inOrder = false) |
| 19166: | { |
| 19167: | return \Livewire\Testing\TestableLivewire::assertCanSeeTableRecords($records, $inOrder); |
| 19168: | } |
| 19169: | /** |
| 19170: | * |
| 19171: | * |
| 19172: | * @see \Filament\Tables\Testing\TestsRecords::assertCanNotSeeTableRecords() |
| 19173: | * @param \Illuminate\Support\Collection|array $records |
| 19174: | * @return static |
| 19175: | * @static |
| 19176: | */ |
| 19177: | public static function assertCanNotSeeTableRecords($records) |
| 19178: | { |
| 19179: | return \Livewire\Testing\TestableLivewire::assertCanNotSeeTableRecords($records); |
| 19180: | } |
| 19181: | /** |
| 19182: | * |
| 19183: | * |
| 19184: | * @see \Filament\Tables\Testing\TestsRecords::assertCountTableRecords() |
| 19185: | * @param int $count |
| 19186: | * @return static |
| 19187: | * @static |
| 19188: | */ |
| 19189: | public static function assertCountTableRecords($count) |
| 19190: | { |
| 19191: | return \Livewire\Testing\TestableLivewire::assertCountTableRecords($count); |
| 19192: | } |
| 19193: | |
| 19194: | } |
| 19195: | |
| 19196: | } |
| 19197: | |
| 19198: | namespace Illuminate\Testing { |
| 19199: | /** |
| 19200: | * |
| 19201: | * |
| 19202: | * @mixin \Illuminate\Http\Response |
| 19203: | */ |
| 19204: | class TestResponse { |
| 19205: | /** |
| 19206: | * |
| 19207: | * |
| 19208: | * @see \Livewire\LivewireServiceProvider::registerTestMacros() |
| 19209: | * @param mixed $component |
| 19210: | * @static |
| 19211: | */ |
| 19212: | public static function assertSeeLivewire($component) |
| 19213: | { |
| 19214: | return \Illuminate\Testing\TestResponse::assertSeeLivewire($component); |
| 19215: | } |
| 19216: | /** |
| 19217: | * |
| 19218: | * |
| 19219: | * @see \Livewire\LivewireServiceProvider::registerTestMacros() |
| 19220: | * @param mixed $component |
| 19221: | * @static |
| 19222: | */ |
| 19223: | public static function assertDontSeeLivewire($component) |
| 19224: | { |
| 19225: | return \Illuminate\Testing\TestResponse::assertDontSeeLivewire($component); |
| 19226: | } |
| 19227: | /** |
| 19228: | * |
| 19229: | * |
| 19230: | * @see \Spatie\LaravelRay\RayServiceProvider::registerMacros() |
| 19231: | * @static |
| 19232: | */ |
| 19233: | public static function ray() |
| 19234: | { |
| 19235: | return \Illuminate\Testing\TestResponse::ray(); |
| 19236: | } |
| 19237: | |
| 19238: | } |
| 19239: | /** |
| 19240: | * |
| 19241: | * |
| 19242: | */ |
| 19243: | class TestView { |
| 19244: | /** |
| 19245: | * |
| 19246: | * |
| 19247: | * @see \Livewire\LivewireServiceProvider::registerTestMacros() |
| 19248: | * @param mixed $component |
| 19249: | * @static |
| 19250: | */ |
| 19251: | public static function assertSeeLivewire($component) |
| 19252: | { |
| 19253: | return \Illuminate\Testing\TestView::assertSeeLivewire($component); |
| 19254: | } |
| 19255: | /** |
| 19256: | * |
| 19257: | * |
| 19258: | * @see \Livewire\LivewireServiceProvider::registerTestMacros() |
| 19259: | * @param mixed $component |
| 19260: | * @static |
| 19261: | */ |
| 19262: | public static function assertDontSeeLivewire($component) |
| 19263: | { |
| 19264: | return \Illuminate\Testing\TestView::assertDontSeeLivewire($component); |
| 19265: | } |
| 19266: | |
| 19267: | } |
| 19268: | |
| 19269: | } |
| 19270: | |
| 19271: | namespace Illuminate\Database\Query { |
| 19272: | /** |
| 19273: | * |
| 19274: | * |
| 19275: | */ |
| 19276: | class Builder { |
| 19277: | /** |
| 19278: | * |
| 19279: | * |
| 19280: | * @see \Spatie\LaravelRay\RayServiceProvider::registerMacros() |
| 19281: | * @static |
| 19282: | */ |
| 19283: | public static function ray() |
| 19284: | { |
| 19285: | return \Illuminate\Database\Query\Builder::ray(); |
| 19286: | } |
| 19287: | |
| 19288: | } |
| 19289: | |
| 19290: | } |
| 19291: | |
| 19292: | namespace Illuminate\Http\Client { |
| 19293: | /** |
| 19294: | * |
| 19295: | * |
| 19296: | */ |
| 19297: | class PendingRequest { |
| 19298: | /** |
| 19299: | * |
| 19300: | * |
| 19301: | * @see \Bilfeldt\LaravelHttpClientLogger\LaravelHttpClientLoggerServiceProvider::packageBooted() |
| 19302: | * @param mixed $context |
| 19303: | * @param mixed $config |
| 19304: | * @param \Bilfeldt\LaravelHttpClientLogger\HttpLoggerInterface|null $logger |
| 19305: | * @param \Bilfeldt\LaravelHttpClientLogger\HttpLoggingFilterInterface|null $filter |
| 19306: | * @static |
| 19307: | */ |
| 19308: | public static function log($context = [], $config = [], $logger = null, $filter = null) |
| 19309: | { |
| 19310: | return \Illuminate\Http\Client\PendingRequest::log($context, $config, $logger, $filter); |
| 19311: | } |
| 19312: | /** |
| 19313: | * |
| 19314: | * |
| 19315: | * @see \Bilfeldt\LaravelHttpClientLogger\LaravelHttpClientLoggerServiceProvider::packageBooted() |
| 19316: | * @param mixed $condition |
| 19317: | * @param mixed $context |
| 19318: | * @param mixed $config |
| 19319: | * @param \Bilfeldt\LaravelHttpClientLogger\HttpLoggerInterface|null $logger |
| 19320: | * @param \Bilfeldt\LaravelHttpClientLogger\HttpLoggingFilterInterface|null $filter |
| 19321: | * @static |
| 19322: | */ |
| 19323: | public static function logWhen($condition, $context = [], $config = [], $logger = null, $filter = null) |
| 19324: | { |
| 19325: | return \Illuminate\Http\Client\PendingRequest::logWhen($condition, $context, $config, $logger, $filter); |
| 19326: | } |
| 19327: | /** |
| 19328: | * |
| 19329: | * |
| 19330: | * @see \Bilfeldt\LaravelHttpClientLogger\LaravelHttpClientLoggerServiceProvider::packageBooted() |
| 19331: | * @param \Bilfeldt\LaravelHttpClientLogger\HttpLoggerInterface|null $logger |
| 19332: | * @static |
| 19333: | */ |
| 19334: | public static function logWith($logger = null) |
| 19335: | { |
| 19336: | return \Illuminate\Http\Client\PendingRequest::logWith($logger); |
| 19337: | } |
| 19338: | |
| 19339: | } |
| 19340: | |
| 19341: | } |
| 19342: | |
| 19343: | namespace Illuminate\View { |
| 19344: | /** |
| 19345: | * |
| 19346: | * |
| 19347: | */ |
| 19348: | class ComponentAttributeBag { |
| 19349: | /** |
| 19350: | * |
| 19351: | * |
| 19352: | * @see \Livewire\LivewireServiceProvider::registerViewMacros() |
| 19353: | * @param mixed $name |
| 19354: | * @static |
| 19355: | */ |
| 19356: | public static function wire($name) |
| 19357: | { |
| 19358: | return \Illuminate\View\ComponentAttributeBag::wire($name); |
| 19359: | } |
| 19360: | |
| 19361: | } |
| 19362: | /** |
| 19363: | * |
| 19364: | * |
| 19365: | */ |
| 19366: | class View { |
| 19367: | /** |
| 19368: | * |
| 19369: | * |
| 19370: | * @see \Livewire\Macros\ViewMacros::extends() |
| 19371: | * @param mixed $view |
| 19372: | * @param mixed $params |
| 19373: | * @static |
| 19374: | */ |
| 19375: | public static function extends($view, $params = []) |
| 19376: | { |
| 19377: | return \Illuminate\View\View::extends($view, $params); |
| 19378: | } |
| 19379: | /** |
| 19380: | * |
| 19381: | * |
| 19382: | * @see \Livewire\Macros\ViewMacros::layout() |
| 19383: | * @param mixed $view |
| 19384: | * @param mixed $params |
| 19385: | * @static |
| 19386: | */ |
| 19387: | public static function layout($view, $params = []) |
| 19388: | { |
| 19389: | return \Illuminate\View\View::layout($view, $params); |
| 19390: | } |
| 19391: | /** |
| 19392: | * |
| 19393: | * |
| 19394: | * @see \Livewire\Macros\ViewMacros::layoutData() |
| 19395: | * @param mixed $data |
| 19396: | * @static |
| 19397: | */ |
| 19398: | public static function layoutData($data = []) |
| 19399: | { |
| 19400: | return \Illuminate\View\View::layoutData($data); |
| 19401: | } |
| 19402: | /** |
| 19403: | * |
| 19404: | * |
| 19405: | * @see \Livewire\Macros\ViewMacros::section() |
| 19406: | * @param mixed $section |
| 19407: | * @static |
| 19408: | */ |
| 19409: | public static function section($section) |
| 19410: | { |
| 19411: | return \Illuminate\View\View::section($section); |
| 19412: | } |
| 19413: | /** |
| 19414: | * |
| 19415: | * |
| 19416: | * @see \Livewire\Macros\ViewMacros::slot() |
| 19417: | * @param mixed $slot |
| 19418: | * @static |
| 19419: | */ |
| 19420: | public static function slot($slot) |
| 19421: | { |
| 19422: | return \Illuminate\View\View::slot($slot); |
| 19423: | } |
| 19424: | |
| 19425: | } |
| 19426: | |
| 19427: | } |
| 19428: | |
| 19429: | |
| 19430: | namespace { |
| 19431: | class App extends \Illuminate\Support\Facades\App {} |
| 19432: | class Arr extends \Illuminate\Support\Arr {} |
| 19433: | class Artisan extends \Illuminate\Support\Facades\Artisan {} |
| 19434: | class Auth extends \Illuminate\Support\Facades\Auth {} |
| 19435: | class Blade extends \Illuminate\Support\Facades\Blade {} |
| 19436: | class Broadcast extends \Illuminate\Support\Facades\Broadcast {} |
| 19437: | class Bus extends \Illuminate\Support\Facades\Bus {} |
| 19438: | class Cache extends \Illuminate\Support\Facades\Cache {} |
| 19439: | class Config extends \Illuminate\Support\Facades\Config {} |
| 19440: | class Cookie extends \Illuminate\Support\Facades\Cookie {} |
| 19441: | class Crypt extends \Illuminate\Support\Facades\Crypt {} |
| 19442: | class Date extends \Illuminate\Support\Facades\Date {} |
| 19443: | class DB extends \Illuminate\Support\Facades\DB {} |
| 19444: | class Eloquent extends \Illuminate\Database\Eloquent\Model { |
| 19445: | /** |
| 19446: | * Create and return an un-saved model instance. |
| 19447: | * |
| 19448: | * @param array $attributes |
| 19449: | * @return \Illuminate\Database\Eloquent\Model|static |
| 19450: | * @static |
| 19451: | */ |
| 19452: | public static function make($attributes = []) |
| 19453: | { |
| 19454: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19455: | return $instance->make($attributes); |
| 19456: | } |
| 19457: | |
| 19458: | /** |
| 19459: | * Register a new global scope. |
| 19460: | * |
| 19461: | * @param string $identifier |
| 19462: | * @param \Illuminate\Database\Eloquent\Scope|\Closure $scope |
| 19463: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 19464: | * @static |
| 19465: | */ |
| 19466: | public static function withGlobalScope($identifier, $scope) |
| 19467: | { |
| 19468: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19469: | return $instance->withGlobalScope($identifier, $scope); |
| 19470: | } |
| 19471: | |
| 19472: | /** |
| 19473: | * Remove a registered global scope. |
| 19474: | * |
| 19475: | * @param \Illuminate\Database\Eloquent\Scope|string $scope |
| 19476: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 19477: | * @static |
| 19478: | */ |
| 19479: | public static function withoutGlobalScope($scope) |
| 19480: | { |
| 19481: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19482: | return $instance->withoutGlobalScope($scope); |
| 19483: | } |
| 19484: | |
| 19485: | /** |
| 19486: | * Remove all or passed registered global scopes. |
| 19487: | * |
| 19488: | * @param array|null $scopes |
| 19489: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 19490: | * @static |
| 19491: | */ |
| 19492: | public static function withoutGlobalScopes($scopes = null) |
| 19493: | { |
| 19494: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19495: | return $instance->withoutGlobalScopes($scopes); |
| 19496: | } |
| 19497: | |
| 19498: | /** |
| 19499: | * Get an array of global scopes that were removed from the query. |
| 19500: | * |
| 19501: | * @return array |
| 19502: | * @static |
| 19503: | */ |
| 19504: | public static function removedScopes() |
| 19505: | { |
| 19506: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19507: | return $instance->removedScopes(); |
| 19508: | } |
| 19509: | |
| 19510: | /** |
| 19511: | * Add a where clause on the primary key to the query. |
| 19512: | * |
| 19513: | * @param mixed $id |
| 19514: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 19515: | * @static |
| 19516: | */ |
| 19517: | public static function whereKey($id) |
| 19518: | { |
| 19519: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19520: | return $instance->whereKey($id); |
| 19521: | } |
| 19522: | |
| 19523: | /** |
| 19524: | * Add a where clause on the primary key to the query. |
| 19525: | * |
| 19526: | * @param mixed $id |
| 19527: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 19528: | * @static |
| 19529: | */ |
| 19530: | public static function whereKeyNot($id) |
| 19531: | { |
| 19532: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19533: | return $instance->whereKeyNot($id); |
| 19534: | } |
| 19535: | |
| 19536: | /** |
| 19537: | * Add a basic where clause to the query. |
| 19538: | * |
| 19539: | * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column |
| 19540: | * @param mixed $operator |
| 19541: | * @param mixed $value |
| 19542: | * @param string $boolean |
| 19543: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 19544: | * @static |
| 19545: | */ |
| 19546: | public static function where($column, $operator = null, $value = null, $boolean = 'and') |
| 19547: | { |
| 19548: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19549: | return $instance->where($column, $operator, $value, $boolean); |
| 19550: | } |
| 19551: | |
| 19552: | /** |
| 19553: | * Add a basic where clause to the query, and return the first result. |
| 19554: | * |
| 19555: | * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column |
| 19556: | * @param mixed $operator |
| 19557: | * @param mixed $value |
| 19558: | * @param string $boolean |
| 19559: | * @return \Illuminate\Database\Eloquent\Model|static|null |
| 19560: | * @static |
| 19561: | */ |
| 19562: | public static function firstWhere($column, $operator = null, $value = null, $boolean = 'and') |
| 19563: | { |
| 19564: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19565: | return $instance->firstWhere($column, $operator, $value, $boolean); |
| 19566: | } |
| 19567: | |
| 19568: | /** |
| 19569: | * Add an "or where" clause to the query. |
| 19570: | * |
| 19571: | * @param \Closure|array|string|\Illuminate\Database\Query\Expression $column |
| 19572: | * @param mixed $operator |
| 19573: | * @param mixed $value |
| 19574: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 19575: | * @static |
| 19576: | */ |
| 19577: | public static function orWhere($column, $operator = null, $value = null) |
| 19578: | { |
| 19579: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19580: | return $instance->orWhere($column, $operator, $value); |
| 19581: | } |
| 19582: | |
| 19583: | /** |
| 19584: | * Add a basic "where not" clause to the query. |
| 19585: | * |
| 19586: | * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column |
| 19587: | * @param mixed $operator |
| 19588: | * @param mixed $value |
| 19589: | * @param string $boolean |
| 19590: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 19591: | * @static |
| 19592: | */ |
| 19593: | public static function whereNot($column, $operator = null, $value = null, $boolean = 'and') |
| 19594: | { |
| 19595: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19596: | return $instance->whereNot($column, $operator, $value, $boolean); |
| 19597: | } |
| 19598: | |
| 19599: | /** |
| 19600: | * Add an "or where not" clause to the query. |
| 19601: | * |
| 19602: | * @param \Closure|array|string|\Illuminate\Database\Query\Expression $column |
| 19603: | * @param mixed $operator |
| 19604: | * @param mixed $value |
| 19605: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 19606: | * @static |
| 19607: | */ |
| 19608: | public static function orWhereNot($column, $operator = null, $value = null) |
| 19609: | { |
| 19610: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19611: | return $instance->orWhereNot($column, $operator, $value); |
| 19612: | } |
| 19613: | |
| 19614: | /** |
| 19615: | * Add an "order by" clause for a timestamp to the query. |
| 19616: | * |
| 19617: | * @param string|\Illuminate\Database\Query\Expression $column |
| 19618: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 19619: | * @static |
| 19620: | */ |
| 19621: | public static function latest($column = null) |
| 19622: | { |
| 19623: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19624: | return $instance->latest($column); |
| 19625: | } |
| 19626: | |
| 19627: | /** |
| 19628: | * Add an "order by" clause for a timestamp to the query. |
| 19629: | * |
| 19630: | * @param string|\Illuminate\Database\Query\Expression $column |
| 19631: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 19632: | * @static |
| 19633: | */ |
| 19634: | public static function oldest($column = null) |
| 19635: | { |
| 19636: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19637: | return $instance->oldest($column); |
| 19638: | } |
| 19639: | |
| 19640: | /** |
| 19641: | * Create a collection of models from plain arrays. |
| 19642: | * |
| 19643: | * @param array $items |
| 19644: | * @return \Illuminate\Database\Eloquent\Collection |
| 19645: | * @static |
| 19646: | */ |
| 19647: | public static function hydrate($items) |
| 19648: | { |
| 19649: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19650: | return $instance->hydrate($items); |
| 19651: | } |
| 19652: | |
| 19653: | /** |
| 19654: | * Create a collection of models from a raw query. |
| 19655: | * |
| 19656: | * @param string $query |
| 19657: | * @param array $bindings |
| 19658: | * @return \Illuminate\Database\Eloquent\Collection |
| 19659: | * @static |
| 19660: | */ |
| 19661: | public static function fromQuery($query, $bindings = []) |
| 19662: | { |
| 19663: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19664: | return $instance->fromQuery($query, $bindings); |
| 19665: | } |
| 19666: | |
| 19667: | /** |
| 19668: | * Find a model by its primary key. |
| 19669: | * |
| 19670: | * @param mixed $id |
| 19671: | * @param array|string $columns |
| 19672: | * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static[]|static|null |
| 19673: | * @static |
| 19674: | */ |
| 19675: | public static function find($id, $columns = []) |
| 19676: | { |
| 19677: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19678: | return $instance->find($id, $columns); |
| 19679: | } |
| 19680: | |
| 19681: | /** |
| 19682: | * Find multiple models by their primary keys. |
| 19683: | * |
| 19684: | * @param \Illuminate\Contracts\Support\Arrayable|array $ids |
| 19685: | * @param array|string $columns |
| 19686: | * @return \Illuminate\Database\Eloquent\Collection |
| 19687: | * @static |
| 19688: | */ |
| 19689: | public static function findMany($ids, $columns = []) |
| 19690: | { |
| 19691: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19692: | return $instance->findMany($ids, $columns); |
| 19693: | } |
| 19694: | |
| 19695: | /** |
| 19696: | * Find a model by its primary key or throw an exception. |
| 19697: | * |
| 19698: | * @param mixed $id |
| 19699: | * @param array|string $columns |
| 19700: | * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static|static[] |
| 19701: | * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model> |
| 19702: | * @static |
| 19703: | */ |
| 19704: | public static function findOrFail($id, $columns = []) |
| 19705: | { |
| 19706: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19707: | return $instance->findOrFail($id, $columns); |
| 19708: | } |
| 19709: | |
| 19710: | /** |
| 19711: | * Find a model by its primary key or return fresh model instance. |
| 19712: | * |
| 19713: | * @param mixed $id |
| 19714: | * @param array|string $columns |
| 19715: | * @return \Illuminate\Database\Eloquent\Model|static |
| 19716: | * @static |
| 19717: | */ |
| 19718: | public static function findOrNew($id, $columns = []) |
| 19719: | { |
| 19720: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19721: | return $instance->findOrNew($id, $columns); |
| 19722: | } |
| 19723: | |
| 19724: | /** |
| 19725: | * Find a model by its primary key or call a callback. |
| 19726: | * |
| 19727: | * @param mixed $id |
| 19728: | * @param \Closure|array|string $columns |
| 19729: | * @param \Closure|null $callback |
| 19730: | * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static[]|static|mixed |
| 19731: | * @static |
| 19732: | */ |
| 19733: | public static function findOr($id, $columns = [], $callback = null) |
| 19734: | { |
| 19735: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19736: | return $instance->findOr($id, $columns, $callback); |
| 19737: | } |
| 19738: | |
| 19739: | /** |
| 19740: | * Get the first record matching the attributes or instantiate it. |
| 19741: | * |
| 19742: | * @param array $attributes |
| 19743: | * @param array $values |
| 19744: | * @return \Illuminate\Database\Eloquent\Model|static |
| 19745: | * @static |
| 19746: | */ |
| 19747: | public static function firstOrNew($attributes = [], $values = []) |
| 19748: | { |
| 19749: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19750: | return $instance->firstOrNew($attributes, $values); |
| 19751: | } |
| 19752: | |
| 19753: | /** |
| 19754: | * Get the first record matching the attributes or create it. |
| 19755: | * |
| 19756: | * @param array $attributes |
| 19757: | * @param array $values |
| 19758: | * @return \Illuminate\Database\Eloquent\Model|static |
| 19759: | * @static |
| 19760: | */ |
| 19761: | public static function firstOrCreate($attributes = [], $values = []) |
| 19762: | { |
| 19763: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19764: | return $instance->firstOrCreate($attributes, $values); |
| 19765: | } |
| 19766: | |
| 19767: | /** |
| 19768: | * Create or update a record matching the attributes, and fill it with values. |
| 19769: | * |
| 19770: | * @param array $attributes |
| 19771: | * @param array $values |
| 19772: | * @return \Illuminate\Database\Eloquent\Model|static |
| 19773: | * @static |
| 19774: | */ |
| 19775: | public static function updateOrCreate($attributes, $values = []) |
| 19776: | { |
| 19777: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19778: | return $instance->updateOrCreate($attributes, $values); |
| 19779: | } |
| 19780: | |
| 19781: | /** |
| 19782: | * Execute the query and get the first result or throw an exception. |
| 19783: | * |
| 19784: | * @param array|string $columns |
| 19785: | * @return \Illuminate\Database\Eloquent\Model|static |
| 19786: | * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model> |
| 19787: | * @static |
| 19788: | */ |
| 19789: | public static function firstOrFail($columns = []) |
| 19790: | { |
| 19791: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19792: | return $instance->firstOrFail($columns); |
| 19793: | } |
| 19794: | |
| 19795: | /** |
| 19796: | * Execute the query and get the first result or call a callback. |
| 19797: | * |
| 19798: | * @param \Closure|array|string $columns |
| 19799: | * @param \Closure|null $callback |
| 19800: | * @return \Illuminate\Database\Eloquent\Model|static|mixed |
| 19801: | * @static |
| 19802: | */ |
| 19803: | public static function firstOr($columns = [], $callback = null) |
| 19804: | { |
| 19805: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19806: | return $instance->firstOr($columns, $callback); |
| 19807: | } |
| 19808: | |
| 19809: | /** |
| 19810: | * Execute the query and get the first result if it's the sole matching record. |
| 19811: | * |
| 19812: | * @param array|string $columns |
| 19813: | * @return \Illuminate\Database\Eloquent\Model |
| 19814: | * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model> |
| 19815: | * @throws \Illuminate\Database\MultipleRecordsFoundException |
| 19816: | * @static |
| 19817: | */ |
| 19818: | public static function sole($columns = []) |
| 19819: | { |
| 19820: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19821: | return $instance->sole($columns); |
| 19822: | } |
| 19823: | |
| 19824: | /** |
| 19825: | * Get a single column's value from the first result of a query. |
| 19826: | * |
| 19827: | * @param string|\Illuminate\Database\Query\Expression $column |
| 19828: | * @return mixed |
| 19829: | * @static |
| 19830: | */ |
| 19831: | public static function value($column) |
| 19832: | { |
| 19833: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19834: | return $instance->value($column); |
| 19835: | } |
| 19836: | |
| 19837: | /** |
| 19838: | * Get a single column's value from the first result of a query if it's the sole matching record. |
| 19839: | * |
| 19840: | * @param string|\Illuminate\Database\Query\Expression $column |
| 19841: | * @return mixed |
| 19842: | * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model> |
| 19843: | * @throws \Illuminate\Database\MultipleRecordsFoundException |
| 19844: | * @static |
| 19845: | */ |
| 19846: | public static function soleValue($column) |
| 19847: | { |
| 19848: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19849: | return $instance->soleValue($column); |
| 19850: | } |
| 19851: | |
| 19852: | /** |
| 19853: | * Get a single column's value from the first result of the query or throw an exception. |
| 19854: | * |
| 19855: | * @param string|\Illuminate\Database\Query\Expression $column |
| 19856: | * @return mixed |
| 19857: | * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model> |
| 19858: | * @static |
| 19859: | */ |
| 19860: | public static function valueOrFail($column) |
| 19861: | { |
| 19862: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19863: | return $instance->valueOrFail($column); |
| 19864: | } |
| 19865: | |
| 19866: | /** |
| 19867: | * Execute the query as a "select" statement. |
| 19868: | * |
| 19869: | * @param array|string $columns |
| 19870: | * @return \Illuminate\Database\Eloquent\Collection|static[] |
| 19871: | * @static |
| 19872: | */ |
| 19873: | public static function get($columns = []) |
| 19874: | { |
| 19875: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19876: | return $instance->get($columns); |
| 19877: | } |
| 19878: | |
| 19879: | /** |
| 19880: | * Get the hydrated models without eager loading. |
| 19881: | * |
| 19882: | * @param array|string $columns |
| 19883: | * @return \Illuminate\Database\Eloquent\Model[]|static[] |
| 19884: | * @static |
| 19885: | */ |
| 19886: | public static function getModels($columns = []) |
| 19887: | { |
| 19888: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19889: | return $instance->getModels($columns); |
| 19890: | } |
| 19891: | |
| 19892: | /** |
| 19893: | * Eager load the relationships for the models. |
| 19894: | * |
| 19895: | * @param array $models |
| 19896: | * @return array |
| 19897: | * @static |
| 19898: | */ |
| 19899: | public static function eagerLoadRelations($models) |
| 19900: | { |
| 19901: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19902: | return $instance->eagerLoadRelations($models); |
| 19903: | } |
| 19904: | |
| 19905: | /** |
| 19906: | * Get a lazy collection for the given query. |
| 19907: | * |
| 19908: | * @return \Illuminate\Support\LazyCollection |
| 19909: | * @static |
| 19910: | */ |
| 19911: | public static function cursor() |
| 19912: | { |
| 19913: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19914: | return $instance->cursor(); |
| 19915: | } |
| 19916: | |
| 19917: | /** |
| 19918: | * Get an array with the values of a given column. |
| 19919: | * |
| 19920: | * @param string|\Illuminate\Database\Query\Expression $column |
| 19921: | * @param string|null $key |
| 19922: | * @return \Illuminate\Support\Collection |
| 19923: | * @static |
| 19924: | */ |
| 19925: | public static function pluck($column, $key = null) |
| 19926: | { |
| 19927: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19928: | return $instance->pluck($column, $key); |
| 19929: | } |
| 19930: | |
| 19931: | /** |
| 19932: | * Paginate the given query. |
| 19933: | * |
| 19934: | * @param int|null|\Closure $perPage |
| 19935: | * @param array|string $columns |
| 19936: | * @param string $pageName |
| 19937: | * @param int|null $page |
| 19938: | * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator |
| 19939: | * @throws \InvalidArgumentException |
| 19940: | * @static |
| 19941: | */ |
| 19942: | public static function paginate($perPage = null, $columns = [], $pageName = 'page', $page = null) |
| 19943: | { |
| 19944: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19945: | return $instance->paginate($perPage, $columns, $pageName, $page); |
| 19946: | } |
| 19947: | |
| 19948: | /** |
| 19949: | * Paginate the given query into a simple paginator. |
| 19950: | * |
| 19951: | * @param int|null $perPage |
| 19952: | * @param array|string $columns |
| 19953: | * @param string $pageName |
| 19954: | * @param int|null $page |
| 19955: | * @return \Illuminate\Contracts\Pagination\Paginator |
| 19956: | * @static |
| 19957: | */ |
| 19958: | public static function simplePaginate($perPage = null, $columns = [], $pageName = 'page', $page = null) |
| 19959: | { |
| 19960: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19961: | return $instance->simplePaginate($perPage, $columns, $pageName, $page); |
| 19962: | } |
| 19963: | |
| 19964: | /** |
| 19965: | * Paginate the given query into a cursor paginator. |
| 19966: | * |
| 19967: | * @param int|null $perPage |
| 19968: | * @param array|string $columns |
| 19969: | * @param string $cursorName |
| 19970: | * @param \Illuminate\Pagination\Cursor|string|null $cursor |
| 19971: | * @return \Illuminate\Contracts\Pagination\CursorPaginator |
| 19972: | * @static |
| 19973: | */ |
| 19974: | public static function cursorPaginate($perPage = null, $columns = [], $cursorName = 'cursor', $cursor = null) |
| 19975: | { |
| 19976: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19977: | return $instance->cursorPaginate($perPage, $columns, $cursorName, $cursor); |
| 19978: | } |
| 19979: | |
| 19980: | /** |
| 19981: | * Save a new model and return the instance. |
| 19982: | * |
| 19983: | * @param array $attributes |
| 19984: | * @return \Illuminate\Database\Eloquent\Model|$this |
| 19985: | * @static |
| 19986: | */ |
| 19987: | public static function create($attributes = []) |
| 19988: | { |
| 19989: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 19990: | return $instance->create($attributes); |
| 19991: | } |
| 19992: | |
| 19993: | /** |
| 19994: | * Save a new model and return the instance. Allow mass-assignment. |
| 19995: | * |
| 19996: | * @param array $attributes |
| 19997: | * @return \Illuminate\Database\Eloquent\Model|$this |
| 19998: | * @static |
| 19999: | */ |
| 20000: | public static function forceCreate($attributes) |
| 20001: | { |
| 20002: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20003: | return $instance->forceCreate($attributes); |
| 20004: | } |
| 20005: | |
| 20006: | /** |
| 20007: | * Insert new records or update the existing ones. |
| 20008: | * |
| 20009: | * @param array $values |
| 20010: | * @param array|string $uniqueBy |
| 20011: | * @param array|null $update |
| 20012: | * @return int |
| 20013: | * @static |
| 20014: | */ |
| 20015: | public static function upsert($values, $uniqueBy, $update = null) |
| 20016: | { |
| 20017: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20018: | return $instance->upsert($values, $uniqueBy, $update); |
| 20019: | } |
| 20020: | |
| 20021: | /** |
| 20022: | * Register a replacement for the default delete function. |
| 20023: | * |
| 20024: | * @param \Closure $callback |
| 20025: | * @return void |
| 20026: | * @static |
| 20027: | */ |
| 20028: | public static function onDelete($callback) |
| 20029: | { |
| 20030: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20031: | $instance->onDelete($callback); |
| 20032: | } |
| 20033: | |
| 20034: | /** |
| 20035: | * Call the given local model scopes. |
| 20036: | * |
| 20037: | * @param array|string $scopes |
| 20038: | * @return static|mixed |
| 20039: | * @static |
| 20040: | */ |
| 20041: | public static function scopes($scopes) |
| 20042: | { |
| 20043: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20044: | return $instance->scopes($scopes); |
| 20045: | } |
| 20046: | |
| 20047: | /** |
| 20048: | * Apply the scopes to the Eloquent builder instance and return it. |
| 20049: | * |
| 20050: | * @return static |
| 20051: | * @static |
| 20052: | */ |
| 20053: | public static function applyScopes() |
| 20054: | { |
| 20055: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20056: | return $instance->applyScopes(); |
| 20057: | } |
| 20058: | |
| 20059: | /** |
| 20060: | * Prevent the specified relations from being eager loaded. |
| 20061: | * |
| 20062: | * @param mixed $relations |
| 20063: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20064: | * @static |
| 20065: | */ |
| 20066: | public static function without($relations) |
| 20067: | { |
| 20068: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20069: | return $instance->without($relations); |
| 20070: | } |
| 20071: | |
| 20072: | /** |
| 20073: | * Set the relationships that should be eager loaded while removing any previously added eager loading specifications. |
| 20074: | * |
| 20075: | * @param mixed $relations |
| 20076: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20077: | * @static |
| 20078: | */ |
| 20079: | public static function withOnly($relations) |
| 20080: | { |
| 20081: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20082: | return $instance->withOnly($relations); |
| 20083: | } |
| 20084: | |
| 20085: | /** |
| 20086: | * Create a new instance of the model being queried. |
| 20087: | * |
| 20088: | * @param array $attributes |
| 20089: | * @return \Illuminate\Database\Eloquent\Model|static |
| 20090: | * @static |
| 20091: | */ |
| 20092: | public static function newModelInstance($attributes = []) |
| 20093: | { |
| 20094: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20095: | return $instance->newModelInstance($attributes); |
| 20096: | } |
| 20097: | |
| 20098: | /** |
| 20099: | * Apply query-time casts to the model instance. |
| 20100: | * |
| 20101: | * @param array $casts |
| 20102: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20103: | * @static |
| 20104: | */ |
| 20105: | public static function withCasts($casts) |
| 20106: | { |
| 20107: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20108: | return $instance->withCasts($casts); |
| 20109: | } |
| 20110: | |
| 20111: | /** |
| 20112: | * Get the underlying query builder instance. |
| 20113: | * |
| 20114: | * @return \Illuminate\Database\Query\Builder |
| 20115: | * @static |
| 20116: | */ |
| 20117: | public static function getQuery() |
| 20118: | { |
| 20119: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20120: | return $instance->getQuery(); |
| 20121: | } |
| 20122: | |
| 20123: | /** |
| 20124: | * Set the underlying query builder instance. |
| 20125: | * |
| 20126: | * @param \Illuminate\Database\Query\Builder $query |
| 20127: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20128: | * @static |
| 20129: | */ |
| 20130: | public static function setQuery($query) |
| 20131: | { |
| 20132: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20133: | return $instance->setQuery($query); |
| 20134: | } |
| 20135: | |
| 20136: | /** |
| 20137: | * Get a base query builder instance. |
| 20138: | * |
| 20139: | * @return \Illuminate\Database\Query\Builder |
| 20140: | * @static |
| 20141: | */ |
| 20142: | public static function toBase() |
| 20143: | { |
| 20144: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20145: | return $instance->toBase(); |
| 20146: | } |
| 20147: | |
| 20148: | /** |
| 20149: | * Get the relationships being eagerly loaded. |
| 20150: | * |
| 20151: | * @return array |
| 20152: | * @static |
| 20153: | */ |
| 20154: | public static function getEagerLoads() |
| 20155: | { |
| 20156: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20157: | return $instance->getEagerLoads(); |
| 20158: | } |
| 20159: | |
| 20160: | /** |
| 20161: | * Set the relationships being eagerly loaded. |
| 20162: | * |
| 20163: | * @param array $eagerLoad |
| 20164: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20165: | * @static |
| 20166: | */ |
| 20167: | public static function setEagerLoads($eagerLoad) |
| 20168: | { |
| 20169: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20170: | return $instance->setEagerLoads($eagerLoad); |
| 20171: | } |
| 20172: | |
| 20173: | /** |
| 20174: | * Indicate that the given relationships should not be eagerly loaded. |
| 20175: | * |
| 20176: | * @param array $relations |
| 20177: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20178: | * @static |
| 20179: | */ |
| 20180: | public static function withoutEagerLoad($relations) |
| 20181: | { |
| 20182: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20183: | return $instance->withoutEagerLoad($relations); |
| 20184: | } |
| 20185: | |
| 20186: | /** |
| 20187: | * Flush the relationships being eagerly loaded. |
| 20188: | * |
| 20189: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20190: | * @static |
| 20191: | */ |
| 20192: | public static function withoutEagerLoads() |
| 20193: | { |
| 20194: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20195: | return $instance->withoutEagerLoads(); |
| 20196: | } |
| 20197: | |
| 20198: | /** |
| 20199: | * Get the model instance being queried. |
| 20200: | * |
| 20201: | * @return \Illuminate\Database\Eloquent\Model|static |
| 20202: | * @static |
| 20203: | */ |
| 20204: | public static function getModel() |
| 20205: | { |
| 20206: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20207: | return $instance->getModel(); |
| 20208: | } |
| 20209: | |
| 20210: | /** |
| 20211: | * Set a model instance for the model being queried. |
| 20212: | * |
| 20213: | * @param \Illuminate\Database\Eloquent\Model $model |
| 20214: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20215: | * @static |
| 20216: | */ |
| 20217: | public static function setModel($model) |
| 20218: | { |
| 20219: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20220: | return $instance->setModel($model); |
| 20221: | } |
| 20222: | |
| 20223: | /** |
| 20224: | * Get the given macro by name. |
| 20225: | * |
| 20226: | * @param string $name |
| 20227: | * @return \Closure |
| 20228: | * @static |
| 20229: | */ |
| 20230: | public static function getMacro($name) |
| 20231: | { |
| 20232: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20233: | return $instance->getMacro($name); |
| 20234: | } |
| 20235: | |
| 20236: | /** |
| 20237: | * Checks if a macro is registered. |
| 20238: | * |
| 20239: | * @param string $name |
| 20240: | * @return bool |
| 20241: | * @static |
| 20242: | */ |
| 20243: | public static function hasMacro($name) |
| 20244: | { |
| 20245: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20246: | return $instance->hasMacro($name); |
| 20247: | } |
| 20248: | |
| 20249: | /** |
| 20250: | * Get the given global macro by name. |
| 20251: | * |
| 20252: | * @param string $name |
| 20253: | * @return \Closure |
| 20254: | * @static |
| 20255: | */ |
| 20256: | public static function getGlobalMacro($name) |
| 20257: | { |
| 20258: | return \Illuminate\Database\Eloquent\Builder::getGlobalMacro($name); |
| 20259: | } |
| 20260: | |
| 20261: | /** |
| 20262: | * Checks if a global macro is registered. |
| 20263: | * |
| 20264: | * @param string $name |
| 20265: | * @return bool |
| 20266: | * @static |
| 20267: | */ |
| 20268: | public static function hasGlobalMacro($name) |
| 20269: | { |
| 20270: | return \Illuminate\Database\Eloquent\Builder::hasGlobalMacro($name); |
| 20271: | } |
| 20272: | |
| 20273: | /** |
| 20274: | * Clone the Eloquent query builder. |
| 20275: | * |
| 20276: | * @return static |
| 20277: | * @static |
| 20278: | */ |
| 20279: | public static function clone() |
| 20280: | { |
| 20281: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20282: | return $instance->clone(); |
| 20283: | } |
| 20284: | |
| 20285: | /** |
| 20286: | * Chunk the results of the query. |
| 20287: | * |
| 20288: | * @param int $count |
| 20289: | * @param callable $callback |
| 20290: | * @return bool |
| 20291: | * @static |
| 20292: | */ |
| 20293: | public static function chunk($count, $callback) |
| 20294: | { |
| 20295: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20296: | return $instance->chunk($count, $callback); |
| 20297: | } |
| 20298: | |
| 20299: | /** |
| 20300: | * Run a map over each item while chunking. |
| 20301: | * |
| 20302: | * @param callable $callback |
| 20303: | * @param int $count |
| 20304: | * @return \Illuminate\Support\Collection |
| 20305: | * @static |
| 20306: | */ |
| 20307: | public static function chunkMap($callback, $count = 1000) |
| 20308: | { |
| 20309: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20310: | return $instance->chunkMap($callback, $count); |
| 20311: | } |
| 20312: | |
| 20313: | /** |
| 20314: | * Execute a callback over each item while chunking. |
| 20315: | * |
| 20316: | * @param callable $callback |
| 20317: | * @param int $count |
| 20318: | * @return bool |
| 20319: | * @throws \RuntimeException |
| 20320: | * @static |
| 20321: | */ |
| 20322: | public static function each($callback, $count = 1000) |
| 20323: | { |
| 20324: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20325: | return $instance->each($callback, $count); |
| 20326: | } |
| 20327: | |
| 20328: | /** |
| 20329: | * Chunk the results of a query by comparing IDs. |
| 20330: | * |
| 20331: | * @param int $count |
| 20332: | * @param callable $callback |
| 20333: | * @param string|null $column |
| 20334: | * @param string|null $alias |
| 20335: | * @return bool |
| 20336: | * @static |
| 20337: | */ |
| 20338: | public static function chunkById($count, $callback, $column = null, $alias = null) |
| 20339: | { |
| 20340: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20341: | return $instance->chunkById($count, $callback, $column, $alias); |
| 20342: | } |
| 20343: | |
| 20344: | /** |
| 20345: | * Execute a callback over each item while chunking by ID. |
| 20346: | * |
| 20347: | * @param callable $callback |
| 20348: | * @param int $count |
| 20349: | * @param string|null $column |
| 20350: | * @param string|null $alias |
| 20351: | * @return bool |
| 20352: | * @static |
| 20353: | */ |
| 20354: | public static function eachById($callback, $count = 1000, $column = null, $alias = null) |
| 20355: | { |
| 20356: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20357: | return $instance->eachById($callback, $count, $column, $alias); |
| 20358: | } |
| 20359: | |
| 20360: | /** |
| 20361: | * Query lazily, by chunks of the given size. |
| 20362: | * |
| 20363: | * @param int $chunkSize |
| 20364: | * @return \Illuminate\Support\LazyCollection |
| 20365: | * @throws \InvalidArgumentException |
| 20366: | * @static |
| 20367: | */ |
| 20368: | public static function lazy($chunkSize = 1000) |
| 20369: | { |
| 20370: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20371: | return $instance->lazy($chunkSize); |
| 20372: | } |
| 20373: | |
| 20374: | /** |
| 20375: | * Query lazily, by chunking the results of a query by comparing IDs. |
| 20376: | * |
| 20377: | * @param int $chunkSize |
| 20378: | * @param string|null $column |
| 20379: | * @param string|null $alias |
| 20380: | * @return \Illuminate\Support\LazyCollection |
| 20381: | * @throws \InvalidArgumentException |
| 20382: | * @static |
| 20383: | */ |
| 20384: | public static function lazyById($chunkSize = 1000, $column = null, $alias = null) |
| 20385: | { |
| 20386: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20387: | return $instance->lazyById($chunkSize, $column, $alias); |
| 20388: | } |
| 20389: | |
| 20390: | /** |
| 20391: | * Query lazily, by chunking the results of a query by comparing IDs in descending order. |
| 20392: | * |
| 20393: | * @param int $chunkSize |
| 20394: | * @param string|null $column |
| 20395: | * @param string|null $alias |
| 20396: | * @return \Illuminate\Support\LazyCollection |
| 20397: | * @throws \InvalidArgumentException |
| 20398: | * @static |
| 20399: | */ |
| 20400: | public static function lazyByIdDesc($chunkSize = 1000, $column = null, $alias = null) |
| 20401: | { |
| 20402: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20403: | return $instance->lazyByIdDesc($chunkSize, $column, $alias); |
| 20404: | } |
| 20405: | |
| 20406: | /** |
| 20407: | * Execute the query and get the first result. |
| 20408: | * |
| 20409: | * @param array|string $columns |
| 20410: | * @return \Illuminate\Database\Eloquent\Model|object|static|null |
| 20411: | * @static |
| 20412: | */ |
| 20413: | public static function first($columns = []) |
| 20414: | { |
| 20415: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20416: | return $instance->first($columns); |
| 20417: | } |
| 20418: | |
| 20419: | /** |
| 20420: | * Execute the query and get the first result if it's the sole matching record. |
| 20421: | * |
| 20422: | * @param array|string $columns |
| 20423: | * @return \Illuminate\Database\Eloquent\Model|object|static|null |
| 20424: | * @throws \Illuminate\Database\RecordsNotFoundException |
| 20425: | * @throws \Illuminate\Database\MultipleRecordsFoundException |
| 20426: | * @static |
| 20427: | */ |
| 20428: | public static function baseSole($columns = []) |
| 20429: | { |
| 20430: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20431: | return $instance->baseSole($columns); |
| 20432: | } |
| 20433: | |
| 20434: | /** |
| 20435: | * Pass the query to a given callback. |
| 20436: | * |
| 20437: | * @param callable $callback |
| 20438: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20439: | * @static |
| 20440: | */ |
| 20441: | public static function tap($callback) |
| 20442: | { |
| 20443: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20444: | return $instance->tap($callback); |
| 20445: | } |
| 20446: | |
| 20447: | /** |
| 20448: | * Apply the callback if the given "value" is (or resolves to) truthy. |
| 20449: | * |
| 20450: | * @template TWhenParameter |
| 20451: | * @template TWhenReturnType |
| 20452: | * @param \Illuminate\Database\Eloquent\(\Closure($this): TWhenParameter)|TWhenParameter $value |
| 20453: | * @param \Illuminate\Database\Eloquent\(callable($this, TWhenParameter): TWhenReturnType)|null $callback |
| 20454: | * @param \Illuminate\Database\Eloquent\(callable($this, TWhenParameter): TWhenReturnType)|null $default |
| 20455: | * @return $this|\Illuminate\Database\Eloquent\TWhenReturnType |
| 20456: | * @static |
| 20457: | */ |
| 20458: | public static function when($value, $callback = null, $default = null) |
| 20459: | { |
| 20460: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20461: | return $instance->when($value, $callback, $default); |
| 20462: | } |
| 20463: | |
| 20464: | /** |
| 20465: | * Apply the callback if the given "value" is (or resolves to) falsy. |
| 20466: | * |
| 20467: | * @template TUnlessParameter |
| 20468: | * @template TUnlessReturnType |
| 20469: | * @param \Illuminate\Database\Eloquent\(\Closure($this): TUnlessParameter)|TUnlessParameter $value |
| 20470: | * @param \Illuminate\Database\Eloquent\(callable($this, TUnlessParameter): TUnlessReturnType)|null $callback |
| 20471: | * @param \Illuminate\Database\Eloquent\(callable($this, TUnlessParameter): TUnlessReturnType)|null $default |
| 20472: | * @return $this|\Illuminate\Database\Eloquent\TUnlessReturnType |
| 20473: | * @static |
| 20474: | */ |
| 20475: | public static function unless($value, $callback = null, $default = null) |
| 20476: | { |
| 20477: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20478: | return $instance->unless($value, $callback, $default); |
| 20479: | } |
| 20480: | |
| 20481: | /** |
| 20482: | * Add a relationship count / exists condition to the query. |
| 20483: | * |
| 20484: | * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation |
| 20485: | * @param string $operator |
| 20486: | * @param int $count |
| 20487: | * @param string $boolean |
| 20488: | * @param \Closure|null $callback |
| 20489: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20490: | * @throws \RuntimeException |
| 20491: | * @static |
| 20492: | */ |
| 20493: | public static function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null) |
| 20494: | { |
| 20495: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20496: | return $instance->has($relation, $operator, $count, $boolean, $callback); |
| 20497: | } |
| 20498: | |
| 20499: | /** |
| 20500: | * Add a relationship count / exists condition to the query with an "or". |
| 20501: | * |
| 20502: | * @param string $relation |
| 20503: | * @param string $operator |
| 20504: | * @param int $count |
| 20505: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20506: | * @static |
| 20507: | */ |
| 20508: | public static function orHas($relation, $operator = '>=', $count = 1) |
| 20509: | { |
| 20510: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20511: | return $instance->orHas($relation, $operator, $count); |
| 20512: | } |
| 20513: | |
| 20514: | /** |
| 20515: | * Add a relationship count / exists condition to the query. |
| 20516: | * |
| 20517: | * @param string $relation |
| 20518: | * @param string $boolean |
| 20519: | * @param \Closure|null $callback |
| 20520: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20521: | * @static |
| 20522: | */ |
| 20523: | public static function doesntHave($relation, $boolean = 'and', $callback = null) |
| 20524: | { |
| 20525: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20526: | return $instance->doesntHave($relation, $boolean, $callback); |
| 20527: | } |
| 20528: | |
| 20529: | /** |
| 20530: | * Add a relationship count / exists condition to the query with an "or". |
| 20531: | * |
| 20532: | * @param string $relation |
| 20533: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20534: | * @static |
| 20535: | */ |
| 20536: | public static function orDoesntHave($relation) |
| 20537: | { |
| 20538: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20539: | return $instance->orDoesntHave($relation); |
| 20540: | } |
| 20541: | |
| 20542: | /** |
| 20543: | * Add a relationship count / exists condition to the query with where clauses. |
| 20544: | * |
| 20545: | * @param string $relation |
| 20546: | * @param \Closure|null $callback |
| 20547: | * @param string $operator |
| 20548: | * @param int $count |
| 20549: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20550: | * @static |
| 20551: | */ |
| 20552: | public static function whereHas($relation, $callback = null, $operator = '>=', $count = 1) |
| 20553: | { |
| 20554: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20555: | return $instance->whereHas($relation, $callback, $operator, $count); |
| 20556: | } |
| 20557: | |
| 20558: | /** |
| 20559: | * Add a relationship count / exists condition to the query with where clauses. |
| 20560: | * |
| 20561: | * Also load the relationship with same condition. |
| 20562: | * |
| 20563: | * @param string $relation |
| 20564: | * @param \Closure|null $callback |
| 20565: | * @param string $operator |
| 20566: | * @param int $count |
| 20567: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20568: | * @static |
| 20569: | */ |
| 20570: | public static function withWhereHas($relation, $callback = null, $operator = '>=', $count = 1) |
| 20571: | { |
| 20572: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20573: | return $instance->withWhereHas($relation, $callback, $operator, $count); |
| 20574: | } |
| 20575: | |
| 20576: | /** |
| 20577: | * Add a relationship count / exists condition to the query with where clauses and an "or". |
| 20578: | * |
| 20579: | * @param string $relation |
| 20580: | * @param \Closure|null $callback |
| 20581: | * @param string $operator |
| 20582: | * @param int $count |
| 20583: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20584: | * @static |
| 20585: | */ |
| 20586: | public static function orWhereHas($relation, $callback = null, $operator = '>=', $count = 1) |
| 20587: | { |
| 20588: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20589: | return $instance->orWhereHas($relation, $callback, $operator, $count); |
| 20590: | } |
| 20591: | |
| 20592: | /** |
| 20593: | * Add a relationship count / exists condition to the query with where clauses. |
| 20594: | * |
| 20595: | * @param string $relation |
| 20596: | * @param \Closure|null $callback |
| 20597: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20598: | * @static |
| 20599: | */ |
| 20600: | public static function whereDoesntHave($relation, $callback = null) |
| 20601: | { |
| 20602: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20603: | return $instance->whereDoesntHave($relation, $callback); |
| 20604: | } |
| 20605: | |
| 20606: | /** |
| 20607: | * Add a relationship count / exists condition to the query with where clauses and an "or". |
| 20608: | * |
| 20609: | * @param string $relation |
| 20610: | * @param \Closure|null $callback |
| 20611: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20612: | * @static |
| 20613: | */ |
| 20614: | public static function orWhereDoesntHave($relation, $callback = null) |
| 20615: | { |
| 20616: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20617: | return $instance->orWhereDoesntHave($relation, $callback); |
| 20618: | } |
| 20619: | |
| 20620: | /** |
| 20621: | * Add a polymorphic relationship count / exists condition to the query. |
| 20622: | * |
| 20623: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20624: | * @param string|array $types |
| 20625: | * @param string $operator |
| 20626: | * @param int $count |
| 20627: | * @param string $boolean |
| 20628: | * @param \Closure|null $callback |
| 20629: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20630: | * @static |
| 20631: | */ |
| 20632: | public static function hasMorph($relation, $types, $operator = '>=', $count = 1, $boolean = 'and', $callback = null) |
| 20633: | { |
| 20634: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20635: | return $instance->hasMorph($relation, $types, $operator, $count, $boolean, $callback); |
| 20636: | } |
| 20637: | |
| 20638: | /** |
| 20639: | * Add a polymorphic relationship count / exists condition to the query with an "or". |
| 20640: | * |
| 20641: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20642: | * @param string|array $types |
| 20643: | * @param string $operator |
| 20644: | * @param int $count |
| 20645: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20646: | * @static |
| 20647: | */ |
| 20648: | public static function orHasMorph($relation, $types, $operator = '>=', $count = 1) |
| 20649: | { |
| 20650: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20651: | return $instance->orHasMorph($relation, $types, $operator, $count); |
| 20652: | } |
| 20653: | |
| 20654: | /** |
| 20655: | * Add a polymorphic relationship count / exists condition to the query. |
| 20656: | * |
| 20657: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20658: | * @param string|array $types |
| 20659: | * @param string $boolean |
| 20660: | * @param \Closure|null $callback |
| 20661: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20662: | * @static |
| 20663: | */ |
| 20664: | public static function doesntHaveMorph($relation, $types, $boolean = 'and', $callback = null) |
| 20665: | { |
| 20666: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20667: | return $instance->doesntHaveMorph($relation, $types, $boolean, $callback); |
| 20668: | } |
| 20669: | |
| 20670: | /** |
| 20671: | * Add a polymorphic relationship count / exists condition to the query with an "or". |
| 20672: | * |
| 20673: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20674: | * @param string|array $types |
| 20675: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20676: | * @static |
| 20677: | */ |
| 20678: | public static function orDoesntHaveMorph($relation, $types) |
| 20679: | { |
| 20680: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20681: | return $instance->orDoesntHaveMorph($relation, $types); |
| 20682: | } |
| 20683: | |
| 20684: | /** |
| 20685: | * Add a polymorphic relationship count / exists condition to the query with where clauses. |
| 20686: | * |
| 20687: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20688: | * @param string|array $types |
| 20689: | * @param \Closure|null $callback |
| 20690: | * @param string $operator |
| 20691: | * @param int $count |
| 20692: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20693: | * @static |
| 20694: | */ |
| 20695: | public static function whereHasMorph($relation, $types, $callback = null, $operator = '>=', $count = 1) |
| 20696: | { |
| 20697: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20698: | return $instance->whereHasMorph($relation, $types, $callback, $operator, $count); |
| 20699: | } |
| 20700: | |
| 20701: | /** |
| 20702: | * Add a polymorphic relationship count / exists condition to the query with where clauses and an "or". |
| 20703: | * |
| 20704: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20705: | * @param string|array $types |
| 20706: | * @param \Closure|null $callback |
| 20707: | * @param string $operator |
| 20708: | * @param int $count |
| 20709: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20710: | * @static |
| 20711: | */ |
| 20712: | public static function orWhereHasMorph($relation, $types, $callback = null, $operator = '>=', $count = 1) |
| 20713: | { |
| 20714: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20715: | return $instance->orWhereHasMorph($relation, $types, $callback, $operator, $count); |
| 20716: | } |
| 20717: | |
| 20718: | /** |
| 20719: | * Add a polymorphic relationship count / exists condition to the query with where clauses. |
| 20720: | * |
| 20721: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20722: | * @param string|array $types |
| 20723: | * @param \Closure|null $callback |
| 20724: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20725: | * @static |
| 20726: | */ |
| 20727: | public static function whereDoesntHaveMorph($relation, $types, $callback = null) |
| 20728: | { |
| 20729: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20730: | return $instance->whereDoesntHaveMorph($relation, $types, $callback); |
| 20731: | } |
| 20732: | |
| 20733: | /** |
| 20734: | * Add a polymorphic relationship count / exists condition to the query with where clauses and an "or". |
| 20735: | * |
| 20736: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20737: | * @param string|array $types |
| 20738: | * @param \Closure|null $callback |
| 20739: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20740: | * @static |
| 20741: | */ |
| 20742: | public static function orWhereDoesntHaveMorph($relation, $types, $callback = null) |
| 20743: | { |
| 20744: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20745: | return $instance->orWhereDoesntHaveMorph($relation, $types, $callback); |
| 20746: | } |
| 20747: | |
| 20748: | /** |
| 20749: | * Add a basic where clause to a relationship query. |
| 20750: | * |
| 20751: | * @param string $relation |
| 20752: | * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column |
| 20753: | * @param mixed $operator |
| 20754: | * @param mixed $value |
| 20755: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20756: | * @static |
| 20757: | */ |
| 20758: | public static function whereRelation($relation, $column, $operator = null, $value = null) |
| 20759: | { |
| 20760: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20761: | return $instance->whereRelation($relation, $column, $operator, $value); |
| 20762: | } |
| 20763: | |
| 20764: | /** |
| 20765: | * Add an "or where" clause to a relationship query. |
| 20766: | * |
| 20767: | * @param string $relation |
| 20768: | * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column |
| 20769: | * @param mixed $operator |
| 20770: | * @param mixed $value |
| 20771: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20772: | * @static |
| 20773: | */ |
| 20774: | public static function orWhereRelation($relation, $column, $operator = null, $value = null) |
| 20775: | { |
| 20776: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20777: | return $instance->orWhereRelation($relation, $column, $operator, $value); |
| 20778: | } |
| 20779: | |
| 20780: | /** |
| 20781: | * Add a polymorphic relationship condition to the query with a where clause. |
| 20782: | * |
| 20783: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20784: | * @param string|array $types |
| 20785: | * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column |
| 20786: | * @param mixed $operator |
| 20787: | * @param mixed $value |
| 20788: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20789: | * @static |
| 20790: | */ |
| 20791: | public static function whereMorphRelation($relation, $types, $column, $operator = null, $value = null) |
| 20792: | { |
| 20793: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20794: | return $instance->whereMorphRelation($relation, $types, $column, $operator, $value); |
| 20795: | } |
| 20796: | |
| 20797: | /** |
| 20798: | * Add a polymorphic relationship condition to the query with an "or where" clause. |
| 20799: | * |
| 20800: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20801: | * @param string|array $types |
| 20802: | * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column |
| 20803: | * @param mixed $operator |
| 20804: | * @param mixed $value |
| 20805: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20806: | * @static |
| 20807: | */ |
| 20808: | public static function orWhereMorphRelation($relation, $types, $column, $operator = null, $value = null) |
| 20809: | { |
| 20810: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20811: | return $instance->orWhereMorphRelation($relation, $types, $column, $operator, $value); |
| 20812: | } |
| 20813: | |
| 20814: | /** |
| 20815: | * Add a morph-to relationship condition to the query. |
| 20816: | * |
| 20817: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20818: | * @param \Illuminate\Database\Eloquent\Model|string $model |
| 20819: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20820: | * @static |
| 20821: | */ |
| 20822: | public static function whereMorphedTo($relation, $model, $boolean = 'and') |
| 20823: | { |
| 20824: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20825: | return $instance->whereMorphedTo($relation, $model, $boolean); |
| 20826: | } |
| 20827: | |
| 20828: | /** |
| 20829: | * Add a not morph-to relationship condition to the query. |
| 20830: | * |
| 20831: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20832: | * @param \Illuminate\Database\Eloquent\Model|string $model |
| 20833: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20834: | * @static |
| 20835: | */ |
| 20836: | public static function whereNotMorphedTo($relation, $model, $boolean = 'and') |
| 20837: | { |
| 20838: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20839: | return $instance->whereNotMorphedTo($relation, $model, $boolean); |
| 20840: | } |
| 20841: | |
| 20842: | /** |
| 20843: | * Add a morph-to relationship condition to the query with an "or where" clause. |
| 20844: | * |
| 20845: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20846: | * @param \Illuminate\Database\Eloquent\Model|string $model |
| 20847: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20848: | * @static |
| 20849: | */ |
| 20850: | public static function orWhereMorphedTo($relation, $model) |
| 20851: | { |
| 20852: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20853: | return $instance->orWhereMorphedTo($relation, $model); |
| 20854: | } |
| 20855: | |
| 20856: | /** |
| 20857: | * Add a not morph-to relationship condition to the query with an "or where" clause. |
| 20858: | * |
| 20859: | * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation |
| 20860: | * @param \Illuminate\Database\Eloquent\Model|string $model |
| 20861: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20862: | * @static |
| 20863: | */ |
| 20864: | public static function orWhereNotMorphedTo($relation, $model) |
| 20865: | { |
| 20866: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20867: | return $instance->orWhereNotMorphedTo($relation, $model); |
| 20868: | } |
| 20869: | |
| 20870: | /** |
| 20871: | * Add a "belongs to" relationship where clause to the query. |
| 20872: | * |
| 20873: | * @param \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection<\Illuminate\Database\Eloquent\Model> $related |
| 20874: | * @param string|null $relationshipName |
| 20875: | * @param string $boolean |
| 20876: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20877: | * @throws \Illuminate\Database\Eloquent\RelationNotFoundException |
| 20878: | * @static |
| 20879: | */ |
| 20880: | public static function whereBelongsTo($related, $relationshipName = null, $boolean = 'and') |
| 20881: | { |
| 20882: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20883: | return $instance->whereBelongsTo($related, $relationshipName, $boolean); |
| 20884: | } |
| 20885: | |
| 20886: | /** |
| 20887: | * Add an "BelongsTo" relationship with an "or where" clause to the query. |
| 20888: | * |
| 20889: | * @param \Illuminate\Database\Eloquent\Model $related |
| 20890: | * @param string|null $relationshipName |
| 20891: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20892: | * @throws \RuntimeException |
| 20893: | * @static |
| 20894: | */ |
| 20895: | public static function orWhereBelongsTo($related, $relationshipName = null) |
| 20896: | { |
| 20897: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20898: | return $instance->orWhereBelongsTo($related, $relationshipName); |
| 20899: | } |
| 20900: | |
| 20901: | /** |
| 20902: | * Add subselect queries to include an aggregate value for a relationship. |
| 20903: | * |
| 20904: | * @param mixed $relations |
| 20905: | * @param string $column |
| 20906: | * @param string $function |
| 20907: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20908: | * @static |
| 20909: | */ |
| 20910: | public static function withAggregate($relations, $column, $function = null) |
| 20911: | { |
| 20912: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20913: | return $instance->withAggregate($relations, $column, $function); |
| 20914: | } |
| 20915: | |
| 20916: | /** |
| 20917: | * Add subselect queries to count the relations. |
| 20918: | * |
| 20919: | * @param mixed $relations |
| 20920: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20921: | * @static |
| 20922: | */ |
| 20923: | public static function withCount($relations) |
| 20924: | { |
| 20925: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20926: | return $instance->withCount($relations); |
| 20927: | } |
| 20928: | |
| 20929: | /** |
| 20930: | * Add subselect queries to include the max of the relation's column. |
| 20931: | * |
| 20932: | * @param string|array $relation |
| 20933: | * @param string $column |
| 20934: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20935: | * @static |
| 20936: | */ |
| 20937: | public static function withMax($relation, $column) |
| 20938: | { |
| 20939: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20940: | return $instance->withMax($relation, $column); |
| 20941: | } |
| 20942: | |
| 20943: | /** |
| 20944: | * Add subselect queries to include the min of the relation's column. |
| 20945: | * |
| 20946: | * @param string|array $relation |
| 20947: | * @param string $column |
| 20948: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20949: | * @static |
| 20950: | */ |
| 20951: | public static function withMin($relation, $column) |
| 20952: | { |
| 20953: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20954: | return $instance->withMin($relation, $column); |
| 20955: | } |
| 20956: | |
| 20957: | /** |
| 20958: | * Add subselect queries to include the sum of the relation's column. |
| 20959: | * |
| 20960: | * @param string|array $relation |
| 20961: | * @param string $column |
| 20962: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20963: | * @static |
| 20964: | */ |
| 20965: | public static function withSum($relation, $column) |
| 20966: | { |
| 20967: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20968: | return $instance->withSum($relation, $column); |
| 20969: | } |
| 20970: | |
| 20971: | /** |
| 20972: | * Add subselect queries to include the average of the relation's column. |
| 20973: | * |
| 20974: | * @param string|array $relation |
| 20975: | * @param string $column |
| 20976: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20977: | * @static |
| 20978: | */ |
| 20979: | public static function withAvg($relation, $column) |
| 20980: | { |
| 20981: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20982: | return $instance->withAvg($relation, $column); |
| 20983: | } |
| 20984: | |
| 20985: | /** |
| 20986: | * Add subselect queries to include the existence of related models. |
| 20987: | * |
| 20988: | * @param string|array $relation |
| 20989: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 20990: | * @static |
| 20991: | */ |
| 20992: | public static function withExists($relation) |
| 20993: | { |
| 20994: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 20995: | return $instance->withExists($relation); |
| 20996: | } |
| 20997: | |
| 20998: | /** |
| 20999: | * Merge the where constraints from another query to the current query. |
| 21000: | * |
| 21001: | * @param \Illuminate\Database\Eloquent\Builder $from |
| 21002: | * @return \Illuminate\Database\Eloquent\Builder|static |
| 21003: | * @static |
| 21004: | */ |
| 21005: | public static function mergeConstraintsFrom($from) |
| 21006: | { |
| 21007: | /** @var \Illuminate\Database\Eloquent\Builder $instance */ |
| 21008: | return $instance->mergeConstraintsFrom($from); |
| 21009: | } |
| 21010: | |
| 21011: | /** |
| 21012: | * Set the columns to be selected. |
| 21013: | * |
| 21014: | * @param array|mixed $columns |
| 21015: | * @return \Illuminate\Database\Query\Builder |
| 21016: | * @static |
| 21017: | */ |
| 21018: | public static function select($columns = []) |
| 21019: | { |
| 21020: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21021: | return $instance->select($columns); |
| 21022: | } |
| 21023: | |
| 21024: | /** |
| 21025: | * Add a subselect expression to the query. |
| 21026: | * |
| 21027: | * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query |
| 21028: | * @param string $as |
| 21029: | * @return \Illuminate\Database\Query\Builder |
| 21030: | * @throws \InvalidArgumentException |
| 21031: | * @static |
| 21032: | */ |
| 21033: | public static function selectSub($query, $as) |
| 21034: | { |
| 21035: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21036: | return $instance->selectSub($query, $as); |
| 21037: | } |
| 21038: | |
| 21039: | /** |
| 21040: | * Add a new "raw" select expression to the query. |
| 21041: | * |
| 21042: | * @param string $expression |
| 21043: | * @param array $bindings |
| 21044: | * @return \Illuminate\Database\Query\Builder |
| 21045: | * @static |
| 21046: | */ |
| 21047: | public static function selectRaw($expression, $bindings = []) |
| 21048: | { |
| 21049: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21050: | return $instance->selectRaw($expression, $bindings); |
| 21051: | } |
| 21052: | |
| 21053: | /** |
| 21054: | * Makes "from" fetch from a subquery. |
| 21055: | * |
| 21056: | * @param \Closure|\Illuminate\Database\Query\Builder|string $query |
| 21057: | * @param string $as |
| 21058: | * @return \Illuminate\Database\Query\Builder |
| 21059: | * @throws \InvalidArgumentException |
| 21060: | * @static |
| 21061: | */ |
| 21062: | public static function fromSub($query, $as) |
| 21063: | { |
| 21064: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21065: | return $instance->fromSub($query, $as); |
| 21066: | } |
| 21067: | |
| 21068: | /** |
| 21069: | * Add a raw from clause to the query. |
| 21070: | * |
| 21071: | * @param string $expression |
| 21072: | * @param mixed $bindings |
| 21073: | * @return \Illuminate\Database\Query\Builder |
| 21074: | * @static |
| 21075: | */ |
| 21076: | public static function fromRaw($expression, $bindings = []) |
| 21077: | { |
| 21078: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21079: | return $instance->fromRaw($expression, $bindings); |
| 21080: | } |
| 21081: | |
| 21082: | /** |
| 21083: | * Add a new select column to the query. |
| 21084: | * |
| 21085: | * @param array|mixed $column |
| 21086: | * @return \Illuminate\Database\Query\Builder |
| 21087: | * @static |
| 21088: | */ |
| 21089: | public static function addSelect($column) |
| 21090: | { |
| 21091: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21092: | return $instance->addSelect($column); |
| 21093: | } |
| 21094: | |
| 21095: | /** |
| 21096: | * Force the query to only return distinct results. |
| 21097: | * |
| 21098: | * @return \Illuminate\Database\Query\Builder |
| 21099: | * @static |
| 21100: | */ |
| 21101: | public static function distinct() |
| 21102: | { |
| 21103: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21104: | return $instance->distinct(); |
| 21105: | } |
| 21106: | |
| 21107: | /** |
| 21108: | * Set the table which the query is targeting. |
| 21109: | * |
| 21110: | * @param \Closure|\Illuminate\Database\Query\Builder|string $table |
| 21111: | * @param string|null $as |
| 21112: | * @return \Illuminate\Database\Query\Builder |
| 21113: | * @static |
| 21114: | */ |
| 21115: | public static function from($table, $as = null) |
| 21116: | { |
| 21117: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21118: | return $instance->from($table, $as); |
| 21119: | } |
| 21120: | |
| 21121: | /** |
| 21122: | * Add a join clause to the query. |
| 21123: | * |
| 21124: | * @param string $table |
| 21125: | * @param \Closure|string $first |
| 21126: | * @param string|null $operator |
| 21127: | * @param string|null $second |
| 21128: | * @param string $type |
| 21129: | * @param bool $where |
| 21130: | * @return \Illuminate\Database\Query\Builder |
| 21131: | * @static |
| 21132: | */ |
| 21133: | public static function join($table, $first, $operator = null, $second = null, $type = 'inner', $where = false) |
| 21134: | { |
| 21135: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21136: | return $instance->join($table, $first, $operator, $second, $type, $where); |
| 21137: | } |
| 21138: | |
| 21139: | /** |
| 21140: | * Add a "join where" clause to the query. |
| 21141: | * |
| 21142: | * @param string $table |
| 21143: | * @param \Closure|string $first |
| 21144: | * @param string $operator |
| 21145: | * @param string $second |
| 21146: | * @param string $type |
| 21147: | * @return \Illuminate\Database\Query\Builder |
| 21148: | * @static |
| 21149: | */ |
| 21150: | public static function joinWhere($table, $first, $operator, $second, $type = 'inner') |
| 21151: | { |
| 21152: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21153: | return $instance->joinWhere($table, $first, $operator, $second, $type); |
| 21154: | } |
| 21155: | |
| 21156: | /** |
| 21157: | * Add a subquery join clause to the query. |
| 21158: | * |
| 21159: | * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query |
| 21160: | * @param string $as |
| 21161: | * @param \Closure|string $first |
| 21162: | * @param string|null $operator |
| 21163: | * @param string|null $second |
| 21164: | * @param string $type |
| 21165: | * @param bool $where |
| 21166: | * @return \Illuminate\Database\Query\Builder |
| 21167: | * @throws \InvalidArgumentException |
| 21168: | * @static |
| 21169: | */ |
| 21170: | public static function joinSub($query, $as, $first, $operator = null, $second = null, $type = 'inner', $where = false) |
| 21171: | { |
| 21172: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21173: | return $instance->joinSub($query, $as, $first, $operator, $second, $type, $where); |
| 21174: | } |
| 21175: | |
| 21176: | /** |
| 21177: | * Add a left join to the query. |
| 21178: | * |
| 21179: | * @param string $table |
| 21180: | * @param \Closure|string $first |
| 21181: | * @param string|null $operator |
| 21182: | * @param string|null $second |
| 21183: | * @return \Illuminate\Database\Query\Builder |
| 21184: | * @static |
| 21185: | */ |
| 21186: | public static function leftJoin($table, $first, $operator = null, $second = null) |
| 21187: | { |
| 21188: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21189: | return $instance->leftJoin($table, $first, $operator, $second); |
| 21190: | } |
| 21191: | |
| 21192: | /** |
| 21193: | * Add a "join where" clause to the query. |
| 21194: | * |
| 21195: | * @param string $table |
| 21196: | * @param \Closure|string $first |
| 21197: | * @param string $operator |
| 21198: | * @param string $second |
| 21199: | * @return \Illuminate\Database\Query\Builder |
| 21200: | * @static |
| 21201: | */ |
| 21202: | public static function leftJoinWhere($table, $first, $operator, $second) |
| 21203: | { |
| 21204: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21205: | return $instance->leftJoinWhere($table, $first, $operator, $second); |
| 21206: | } |
| 21207: | |
| 21208: | /** |
| 21209: | * Add a subquery left join to the query. |
| 21210: | * |
| 21211: | * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query |
| 21212: | * @param string $as |
| 21213: | * @param \Closure|string $first |
| 21214: | * @param string|null $operator |
| 21215: | * @param string|null $second |
| 21216: | * @return \Illuminate\Database\Query\Builder |
| 21217: | * @static |
| 21218: | */ |
| 21219: | public static function leftJoinSub($query, $as, $first, $operator = null, $second = null) |
| 21220: | { |
| 21221: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21222: | return $instance->leftJoinSub($query, $as, $first, $operator, $second); |
| 21223: | } |
| 21224: | |
| 21225: | /** |
| 21226: | * Add a right join to the query. |
| 21227: | * |
| 21228: | * @param string $table |
| 21229: | * @param \Closure|string $first |
| 21230: | * @param string|null $operator |
| 21231: | * @param string|null $second |
| 21232: | * @return \Illuminate\Database\Query\Builder |
| 21233: | * @static |
| 21234: | */ |
| 21235: | public static function rightJoin($table, $first, $operator = null, $second = null) |
| 21236: | { |
| 21237: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21238: | return $instance->rightJoin($table, $first, $operator, $second); |
| 21239: | } |
| 21240: | |
| 21241: | /** |
| 21242: | * Add a "right join where" clause to the query. |
| 21243: | * |
| 21244: | * @param string $table |
| 21245: | * @param \Closure|string $first |
| 21246: | * @param string $operator |
| 21247: | * @param string $second |
| 21248: | * @return \Illuminate\Database\Query\Builder |
| 21249: | * @static |
| 21250: | */ |
| 21251: | public static function rightJoinWhere($table, $first, $operator, $second) |
| 21252: | { |
| 21253: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21254: | return $instance->rightJoinWhere($table, $first, $operator, $second); |
| 21255: | } |
| 21256: | |
| 21257: | /** |
| 21258: | * Add a subquery right join to the query. |
| 21259: | * |
| 21260: | * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query |
| 21261: | * @param string $as |
| 21262: | * @param \Closure|string $first |
| 21263: | * @param string|null $operator |
| 21264: | * @param string|null $second |
| 21265: | * @return \Illuminate\Database\Query\Builder |
| 21266: | * @static |
| 21267: | */ |
| 21268: | public static function rightJoinSub($query, $as, $first, $operator = null, $second = null) |
| 21269: | { |
| 21270: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21271: | return $instance->rightJoinSub($query, $as, $first, $operator, $second); |
| 21272: | } |
| 21273: | |
| 21274: | /** |
| 21275: | * Add a "cross join" clause to the query. |
| 21276: | * |
| 21277: | * @param string $table |
| 21278: | * @param \Closure|string|null $first |
| 21279: | * @param string|null $operator |
| 21280: | * @param string|null $second |
| 21281: | * @return \Illuminate\Database\Query\Builder |
| 21282: | * @static |
| 21283: | */ |
| 21284: | public static function crossJoin($table, $first = null, $operator = null, $second = null) |
| 21285: | { |
| 21286: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21287: | return $instance->crossJoin($table, $first, $operator, $second); |
| 21288: | } |
| 21289: | |
| 21290: | /** |
| 21291: | * Add a subquery cross join to the query. |
| 21292: | * |
| 21293: | * @param \Closure|\Illuminate\Database\Query\Builder|string $query |
| 21294: | * @param string $as |
| 21295: | * @return \Illuminate\Database\Query\Builder |
| 21296: | * @static |
| 21297: | */ |
| 21298: | public static function crossJoinSub($query, $as) |
| 21299: | { |
| 21300: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21301: | return $instance->crossJoinSub($query, $as); |
| 21302: | } |
| 21303: | |
| 21304: | /** |
| 21305: | * Merge an array of where clauses and bindings. |
| 21306: | * |
| 21307: | * @param array $wheres |
| 21308: | * @param array $bindings |
| 21309: | * @return \Illuminate\Database\Query\Builder |
| 21310: | * @static |
| 21311: | */ |
| 21312: | public static function mergeWheres($wheres, $bindings) |
| 21313: | { |
| 21314: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21315: | return $instance->mergeWheres($wheres, $bindings); |
| 21316: | } |
| 21317: | |
| 21318: | /** |
| 21319: | * Prepare the value and operator for a where clause. |
| 21320: | * |
| 21321: | * @param string $value |
| 21322: | * @param string $operator |
| 21323: | * @param bool $useDefault |
| 21324: | * @return array |
| 21325: | * @throws \InvalidArgumentException |
| 21326: | * @static |
| 21327: | */ |
| 21328: | public static function prepareValueAndOperator($value, $operator, $useDefault = false) |
| 21329: | { |
| 21330: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21331: | return $instance->prepareValueAndOperator($value, $operator, $useDefault); |
| 21332: | } |
| 21333: | |
| 21334: | /** |
| 21335: | * Add a "where" clause comparing two columns to the query. |
| 21336: | * |
| 21337: | * @param string|array $first |
| 21338: | * @param string|null $operator |
| 21339: | * @param string|null $second |
| 21340: | * @param string|null $boolean |
| 21341: | * @return \Illuminate\Database\Query\Builder |
| 21342: | * @static |
| 21343: | */ |
| 21344: | public static function whereColumn($first, $operator = null, $second = null, $boolean = 'and') |
| 21345: | { |
| 21346: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21347: | return $instance->whereColumn($first, $operator, $second, $boolean); |
| 21348: | } |
| 21349: | |
| 21350: | /** |
| 21351: | * Add an "or where" clause comparing two columns to the query. |
| 21352: | * |
| 21353: | * @param string|array $first |
| 21354: | * @param string|null $operator |
| 21355: | * @param string|null $second |
| 21356: | * @return \Illuminate\Database\Query\Builder |
| 21357: | * @static |
| 21358: | */ |
| 21359: | public static function orWhereColumn($first, $operator = null, $second = null) |
| 21360: | { |
| 21361: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21362: | return $instance->orWhereColumn($first, $operator, $second); |
| 21363: | } |
| 21364: | |
| 21365: | /** |
| 21366: | * Add a raw where clause to the query. |
| 21367: | * |
| 21368: | * @param string $sql |
| 21369: | * @param mixed $bindings |
| 21370: | * @param string $boolean |
| 21371: | * @return \Illuminate\Database\Query\Builder |
| 21372: | * @static |
| 21373: | */ |
| 21374: | public static function whereRaw($sql, $bindings = [], $boolean = 'and') |
| 21375: | { |
| 21376: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21377: | return $instance->whereRaw($sql, $bindings, $boolean); |
| 21378: | } |
| 21379: | |
| 21380: | /** |
| 21381: | * Add a raw or where clause to the query. |
| 21382: | * |
| 21383: | * @param string $sql |
| 21384: | * @param mixed $bindings |
| 21385: | * @return \Illuminate\Database\Query\Builder |
| 21386: | * @static |
| 21387: | */ |
| 21388: | public static function orWhereRaw($sql, $bindings = []) |
| 21389: | { |
| 21390: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21391: | return $instance->orWhereRaw($sql, $bindings); |
| 21392: | } |
| 21393: | |
| 21394: | /** |
| 21395: | * Add a "where in" clause to the query. |
| 21396: | * |
| 21397: | * @param string $column |
| 21398: | * @param mixed $values |
| 21399: | * @param string $boolean |
| 21400: | * @param bool $not |
| 21401: | * @return \Illuminate\Database\Query\Builder |
| 21402: | * @static |
| 21403: | */ |
| 21404: | public static function whereIn($column, $values, $boolean = 'and', $not = false) |
| 21405: | { |
| 21406: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21407: | return $instance->whereIn($column, $values, $boolean, $not); |
| 21408: | } |
| 21409: | |
| 21410: | /** |
| 21411: | * Add an "or where in" clause to the query. |
| 21412: | * |
| 21413: | * @param string $column |
| 21414: | * @param mixed $values |
| 21415: | * @return \Illuminate\Database\Query\Builder |
| 21416: | * @static |
| 21417: | */ |
| 21418: | public static function orWhereIn($column, $values) |
| 21419: | { |
| 21420: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21421: | return $instance->orWhereIn($column, $values); |
| 21422: | } |
| 21423: | |
| 21424: | /** |
| 21425: | * Add a "where not in" clause to the query. |
| 21426: | * |
| 21427: | * @param string $column |
| 21428: | * @param mixed $values |
| 21429: | * @param string $boolean |
| 21430: | * @return \Illuminate\Database\Query\Builder |
| 21431: | * @static |
| 21432: | */ |
| 21433: | public static function whereNotIn($column, $values, $boolean = 'and') |
| 21434: | { |
| 21435: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21436: | return $instance->whereNotIn($column, $values, $boolean); |
| 21437: | } |
| 21438: | |
| 21439: | /** |
| 21440: | * Add an "or where not in" clause to the query. |
| 21441: | * |
| 21442: | * @param string $column |
| 21443: | * @param mixed $values |
| 21444: | * @return \Illuminate\Database\Query\Builder |
| 21445: | * @static |
| 21446: | */ |
| 21447: | public static function orWhereNotIn($column, $values) |
| 21448: | { |
| 21449: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21450: | return $instance->orWhereNotIn($column, $values); |
| 21451: | } |
| 21452: | |
| 21453: | /** |
| 21454: | * Add a "where in raw" clause for integer values to the query. |
| 21455: | * |
| 21456: | * @param string $column |
| 21457: | * @param \Illuminate\Contracts\Support\Arrayable|array $values |
| 21458: | * @param string $boolean |
| 21459: | * @param bool $not |
| 21460: | * @return \Illuminate\Database\Query\Builder |
| 21461: | * @static |
| 21462: | */ |
| 21463: | public static function whereIntegerInRaw($column, $values, $boolean = 'and', $not = false) |
| 21464: | { |
| 21465: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21466: | return $instance->whereIntegerInRaw($column, $values, $boolean, $not); |
| 21467: | } |
| 21468: | |
| 21469: | /** |
| 21470: | * Add an "or where in raw" clause for integer values to the query. |
| 21471: | * |
| 21472: | * @param string $column |
| 21473: | * @param \Illuminate\Contracts\Support\Arrayable|array $values |
| 21474: | * @return \Illuminate\Database\Query\Builder |
| 21475: | * @static |
| 21476: | */ |
| 21477: | public static function orWhereIntegerInRaw($column, $values) |
| 21478: | { |
| 21479: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21480: | return $instance->orWhereIntegerInRaw($column, $values); |
| 21481: | } |
| 21482: | |
| 21483: | /** |
| 21484: | * Add a "where not in raw" clause for integer values to the query. |
| 21485: | * |
| 21486: | * @param string $column |
| 21487: | * @param \Illuminate\Contracts\Support\Arrayable|array $values |
| 21488: | * @param string $boolean |
| 21489: | * @return \Illuminate\Database\Query\Builder |
| 21490: | * @static |
| 21491: | */ |
| 21492: | public static function whereIntegerNotInRaw($column, $values, $boolean = 'and') |
| 21493: | { |
| 21494: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21495: | return $instance->whereIntegerNotInRaw($column, $values, $boolean); |
| 21496: | } |
| 21497: | |
| 21498: | /** |
| 21499: | * Add an "or where not in raw" clause for integer values to the query. |
| 21500: | * |
| 21501: | * @param string $column |
| 21502: | * @param \Illuminate\Contracts\Support\Arrayable|array $values |
| 21503: | * @return \Illuminate\Database\Query\Builder |
| 21504: | * @static |
| 21505: | */ |
| 21506: | public static function orWhereIntegerNotInRaw($column, $values) |
| 21507: | { |
| 21508: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21509: | return $instance->orWhereIntegerNotInRaw($column, $values); |
| 21510: | } |
| 21511: | |
| 21512: | /** |
| 21513: | * Add a "where null" clause to the query. |
| 21514: | * |
| 21515: | * @param string|array $columns |
| 21516: | * @param string $boolean |
| 21517: | * @param bool $not |
| 21518: | * @return \Illuminate\Database\Query\Builder |
| 21519: | * @static |
| 21520: | */ |
| 21521: | public static function whereNull($columns, $boolean = 'and', $not = false) |
| 21522: | { |
| 21523: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21524: | return $instance->whereNull($columns, $boolean, $not); |
| 21525: | } |
| 21526: | |
| 21527: | /** |
| 21528: | * Add an "or where null" clause to the query. |
| 21529: | * |
| 21530: | * @param string|array $column |
| 21531: | * @return \Illuminate\Database\Query\Builder |
| 21532: | * @static |
| 21533: | */ |
| 21534: | public static function orWhereNull($column) |
| 21535: | { |
| 21536: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21537: | return $instance->orWhereNull($column); |
| 21538: | } |
| 21539: | |
| 21540: | /** |
| 21541: | * Add a "where not null" clause to the query. |
| 21542: | * |
| 21543: | * @param string|array $columns |
| 21544: | * @param string $boolean |
| 21545: | * @return \Illuminate\Database\Query\Builder |
| 21546: | * @static |
| 21547: | */ |
| 21548: | public static function whereNotNull($columns, $boolean = 'and') |
| 21549: | { |
| 21550: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21551: | return $instance->whereNotNull($columns, $boolean); |
| 21552: | } |
| 21553: | |
| 21554: | /** |
| 21555: | * Add a where between statement to the query. |
| 21556: | * |
| 21557: | * @param string|\Illuminate\Database\Query\Expression $column |
| 21558: | * @param \Illuminate\Database\Query\iterable $values |
| 21559: | * @param string $boolean |
| 21560: | * @param bool $not |
| 21561: | * @return \Illuminate\Database\Query\Builder |
| 21562: | * @static |
| 21563: | */ |
| 21564: | public static function whereBetween($column, $values, $boolean = 'and', $not = false) |
| 21565: | { |
| 21566: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21567: | return $instance->whereBetween($column, $values, $boolean, $not); |
| 21568: | } |
| 21569: | |
| 21570: | /** |
| 21571: | * Add a where between statement using columns to the query. |
| 21572: | * |
| 21573: | * @param string $column |
| 21574: | * @param array $values |
| 21575: | * @param string $boolean |
| 21576: | * @param bool $not |
| 21577: | * @return \Illuminate\Database\Query\Builder |
| 21578: | * @static |
| 21579: | */ |
| 21580: | public static function whereBetweenColumns($column, $values, $boolean = 'and', $not = false) |
| 21581: | { |
| 21582: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21583: | return $instance->whereBetweenColumns($column, $values, $boolean, $not); |
| 21584: | } |
| 21585: | |
| 21586: | /** |
| 21587: | * Add an or where between statement to the query. |
| 21588: | * |
| 21589: | * @param string $column |
| 21590: | * @param \Illuminate\Database\Query\iterable $values |
| 21591: | * @return \Illuminate\Database\Query\Builder |
| 21592: | * @static |
| 21593: | */ |
| 21594: | public static function orWhereBetween($column, $values) |
| 21595: | { |
| 21596: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21597: | return $instance->orWhereBetween($column, $values); |
| 21598: | } |
| 21599: | |
| 21600: | /** |
| 21601: | * Add an or where between statement using columns to the query. |
| 21602: | * |
| 21603: | * @param string $column |
| 21604: | * @param array $values |
| 21605: | * @return \Illuminate\Database\Query\Builder |
| 21606: | * @static |
| 21607: | */ |
| 21608: | public static function orWhereBetweenColumns($column, $values) |
| 21609: | { |
| 21610: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21611: | return $instance->orWhereBetweenColumns($column, $values); |
| 21612: | } |
| 21613: | |
| 21614: | /** |
| 21615: | * Add a where not between statement to the query. |
| 21616: | * |
| 21617: | * @param string $column |
| 21618: | * @param \Illuminate\Database\Query\iterable $values |
| 21619: | * @param string $boolean |
| 21620: | * @return \Illuminate\Database\Query\Builder |
| 21621: | * @static |
| 21622: | */ |
| 21623: | public static function whereNotBetween($column, $values, $boolean = 'and') |
| 21624: | { |
| 21625: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21626: | return $instance->whereNotBetween($column, $values, $boolean); |
| 21627: | } |
| 21628: | |
| 21629: | /** |
| 21630: | * Add a where not between statement using columns to the query. |
| 21631: | * |
| 21632: | * @param string $column |
| 21633: | * @param array $values |
| 21634: | * @param string $boolean |
| 21635: | * @return \Illuminate\Database\Query\Builder |
| 21636: | * @static |
| 21637: | */ |
| 21638: | public static function whereNotBetweenColumns($column, $values, $boolean = 'and') |
| 21639: | { |
| 21640: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21641: | return $instance->whereNotBetweenColumns($column, $values, $boolean); |
| 21642: | } |
| 21643: | |
| 21644: | /** |
| 21645: | * Add an or where not between statement to the query. |
| 21646: | * |
| 21647: | * @param string $column |
| 21648: | * @param \Illuminate\Database\Query\iterable $values |
| 21649: | * @return \Illuminate\Database\Query\Builder |
| 21650: | * @static |
| 21651: | */ |
| 21652: | public static function orWhereNotBetween($column, $values) |
| 21653: | { |
| 21654: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21655: | return $instance->orWhereNotBetween($column, $values); |
| 21656: | } |
| 21657: | |
| 21658: | /** |
| 21659: | * Add an or where not between statement using columns to the query. |
| 21660: | * |
| 21661: | * @param string $column |
| 21662: | * @param array $values |
| 21663: | * @return \Illuminate\Database\Query\Builder |
| 21664: | * @static |
| 21665: | */ |
| 21666: | public static function orWhereNotBetweenColumns($column, $values) |
| 21667: | { |
| 21668: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21669: | return $instance->orWhereNotBetweenColumns($column, $values); |
| 21670: | } |
| 21671: | |
| 21672: | /** |
| 21673: | * Add an "or where not null" clause to the query. |
| 21674: | * |
| 21675: | * @param string $column |
| 21676: | * @return \Illuminate\Database\Query\Builder |
| 21677: | * @static |
| 21678: | */ |
| 21679: | public static function orWhereNotNull($column) |
| 21680: | { |
| 21681: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21682: | return $instance->orWhereNotNull($column); |
| 21683: | } |
| 21684: | |
| 21685: | /** |
| 21686: | * Add a "where date" statement to the query. |
| 21687: | * |
| 21688: | * @param string $column |
| 21689: | * @param string $operator |
| 21690: | * @param \DateTimeInterface|string|null $value |
| 21691: | * @param string $boolean |
| 21692: | * @return \Illuminate\Database\Query\Builder |
| 21693: | * @static |
| 21694: | */ |
| 21695: | public static function whereDate($column, $operator, $value = null, $boolean = 'and') |
| 21696: | { |
| 21697: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21698: | return $instance->whereDate($column, $operator, $value, $boolean); |
| 21699: | } |
| 21700: | |
| 21701: | /** |
| 21702: | * Add an "or where date" statement to the query. |
| 21703: | * |
| 21704: | * @param string $column |
| 21705: | * @param string $operator |
| 21706: | * @param \DateTimeInterface|string|null $value |
| 21707: | * @return \Illuminate\Database\Query\Builder |
| 21708: | * @static |
| 21709: | */ |
| 21710: | public static function orWhereDate($column, $operator, $value = null) |
| 21711: | { |
| 21712: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21713: | return $instance->orWhereDate($column, $operator, $value); |
| 21714: | } |
| 21715: | |
| 21716: | /** |
| 21717: | * Add a "where time" statement to the query. |
| 21718: | * |
| 21719: | * @param string $column |
| 21720: | * @param string $operator |
| 21721: | * @param \DateTimeInterface|string|null $value |
| 21722: | * @param string $boolean |
| 21723: | * @return \Illuminate\Database\Query\Builder |
| 21724: | * @static |
| 21725: | */ |
| 21726: | public static function whereTime($column, $operator, $value = null, $boolean = 'and') |
| 21727: | { |
| 21728: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21729: | return $instance->whereTime($column, $operator, $value, $boolean); |
| 21730: | } |
| 21731: | |
| 21732: | /** |
| 21733: | * Add an "or where time" statement to the query. |
| 21734: | * |
| 21735: | * @param string $column |
| 21736: | * @param string $operator |
| 21737: | * @param \DateTimeInterface|string|null $value |
| 21738: | * @return \Illuminate\Database\Query\Builder |
| 21739: | * @static |
| 21740: | */ |
| 21741: | public static function orWhereTime($column, $operator, $value = null) |
| 21742: | { |
| 21743: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21744: | return $instance->orWhereTime($column, $operator, $value); |
| 21745: | } |
| 21746: | |
| 21747: | /** |
| 21748: | * Add a "where day" statement to the query. |
| 21749: | * |
| 21750: | * @param string $column |
| 21751: | * @param string $operator |
| 21752: | * @param \DateTimeInterface|string|null $value |
| 21753: | * @param string $boolean |
| 21754: | * @return \Illuminate\Database\Query\Builder |
| 21755: | * @static |
| 21756: | */ |
| 21757: | public static function whereDay($column, $operator, $value = null, $boolean = 'and') |
| 21758: | { |
| 21759: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21760: | return $instance->whereDay($column, $operator, $value, $boolean); |
| 21761: | } |
| 21762: | |
| 21763: | /** |
| 21764: | * Add an "or where day" statement to the query. |
| 21765: | * |
| 21766: | * @param string $column |
| 21767: | * @param string $operator |
| 21768: | * @param \DateTimeInterface|string|null $value |
| 21769: | * @return \Illuminate\Database\Query\Builder |
| 21770: | * @static |
| 21771: | */ |
| 21772: | public static function orWhereDay($column, $operator, $value = null) |
| 21773: | { |
| 21774: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21775: | return $instance->orWhereDay($column, $operator, $value); |
| 21776: | } |
| 21777: | |
| 21778: | /** |
| 21779: | * Add a "where month" statement to the query. |
| 21780: | * |
| 21781: | * @param string $column |
| 21782: | * @param string $operator |
| 21783: | * @param \DateTimeInterface|string|null $value |
| 21784: | * @param string $boolean |
| 21785: | * @return \Illuminate\Database\Query\Builder |
| 21786: | * @static |
| 21787: | */ |
| 21788: | public static function whereMonth($column, $operator, $value = null, $boolean = 'and') |
| 21789: | { |
| 21790: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21791: | return $instance->whereMonth($column, $operator, $value, $boolean); |
| 21792: | } |
| 21793: | |
| 21794: | /** |
| 21795: | * Add an "or where month" statement to the query. |
| 21796: | * |
| 21797: | * @param string $column |
| 21798: | * @param string $operator |
| 21799: | * @param \DateTimeInterface|string|null $value |
| 21800: | * @return \Illuminate\Database\Query\Builder |
| 21801: | * @static |
| 21802: | */ |
| 21803: | public static function orWhereMonth($column, $operator, $value = null) |
| 21804: | { |
| 21805: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21806: | return $instance->orWhereMonth($column, $operator, $value); |
| 21807: | } |
| 21808: | |
| 21809: | /** |
| 21810: | * Add a "where year" statement to the query. |
| 21811: | * |
| 21812: | * @param string $column |
| 21813: | * @param string $operator |
| 21814: | * @param \DateTimeInterface|string|int|null $value |
| 21815: | * @param string $boolean |
| 21816: | * @return \Illuminate\Database\Query\Builder |
| 21817: | * @static |
| 21818: | */ |
| 21819: | public static function whereYear($column, $operator, $value = null, $boolean = 'and') |
| 21820: | { |
| 21821: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21822: | return $instance->whereYear($column, $operator, $value, $boolean); |
| 21823: | } |
| 21824: | |
| 21825: | /** |
| 21826: | * Add an "or where year" statement to the query. |
| 21827: | * |
| 21828: | * @param string $column |
| 21829: | * @param string $operator |
| 21830: | * @param \DateTimeInterface|string|int|null $value |
| 21831: | * @return \Illuminate\Database\Query\Builder |
| 21832: | * @static |
| 21833: | */ |
| 21834: | public static function orWhereYear($column, $operator, $value = null) |
| 21835: | { |
| 21836: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21837: | return $instance->orWhereYear($column, $operator, $value); |
| 21838: | } |
| 21839: | |
| 21840: | /** |
| 21841: | * Add a nested where statement to the query. |
| 21842: | * |
| 21843: | * @param \Closure $callback |
| 21844: | * @param string $boolean |
| 21845: | * @return \Illuminate\Database\Query\Builder |
| 21846: | * @static |
| 21847: | */ |
| 21848: | public static function whereNested($callback, $boolean = 'and') |
| 21849: | { |
| 21850: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21851: | return $instance->whereNested($callback, $boolean); |
| 21852: | } |
| 21853: | |
| 21854: | /** |
| 21855: | * Create a new query instance for nested where condition. |
| 21856: | * |
| 21857: | * @return \Illuminate\Database\Query\Builder |
| 21858: | * @static |
| 21859: | */ |
| 21860: | public static function forNestedWhere() |
| 21861: | { |
| 21862: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21863: | return $instance->forNestedWhere(); |
| 21864: | } |
| 21865: | |
| 21866: | /** |
| 21867: | * Add another query builder as a nested where to the query builder. |
| 21868: | * |
| 21869: | * @param \Illuminate\Database\Query\Builder $query |
| 21870: | * @param string $boolean |
| 21871: | * @return \Illuminate\Database\Query\Builder |
| 21872: | * @static |
| 21873: | */ |
| 21874: | public static function addNestedWhereQuery($query, $boolean = 'and') |
| 21875: | { |
| 21876: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21877: | return $instance->addNestedWhereQuery($query, $boolean); |
| 21878: | } |
| 21879: | |
| 21880: | /** |
| 21881: | * Add an exists clause to the query. |
| 21882: | * |
| 21883: | * @param \Closure $callback |
| 21884: | * @param string $boolean |
| 21885: | * @param bool $not |
| 21886: | * @return \Illuminate\Database\Query\Builder |
| 21887: | * @static |
| 21888: | */ |
| 21889: | public static function whereExists($callback, $boolean = 'and', $not = false) |
| 21890: | { |
| 21891: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21892: | return $instance->whereExists($callback, $boolean, $not); |
| 21893: | } |
| 21894: | |
| 21895: | /** |
| 21896: | * Add an or exists clause to the query. |
| 21897: | * |
| 21898: | * @param \Closure $callback |
| 21899: | * @param bool $not |
| 21900: | * @return \Illuminate\Database\Query\Builder |
| 21901: | * @static |
| 21902: | */ |
| 21903: | public static function orWhereExists($callback, $not = false) |
| 21904: | { |
| 21905: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21906: | return $instance->orWhereExists($callback, $not); |
| 21907: | } |
| 21908: | |
| 21909: | /** |
| 21910: | * Add a where not exists clause to the query. |
| 21911: | * |
| 21912: | * @param \Closure $callback |
| 21913: | * @param string $boolean |
| 21914: | * @return \Illuminate\Database\Query\Builder |
| 21915: | * @static |
| 21916: | */ |
| 21917: | public static function whereNotExists($callback, $boolean = 'and') |
| 21918: | { |
| 21919: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21920: | return $instance->whereNotExists($callback, $boolean); |
| 21921: | } |
| 21922: | |
| 21923: | /** |
| 21924: | * Add a where not exists clause to the query. |
| 21925: | * |
| 21926: | * @param \Closure $callback |
| 21927: | * @return \Illuminate\Database\Query\Builder |
| 21928: | * @static |
| 21929: | */ |
| 21930: | public static function orWhereNotExists($callback) |
| 21931: | { |
| 21932: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21933: | return $instance->orWhereNotExists($callback); |
| 21934: | } |
| 21935: | |
| 21936: | /** |
| 21937: | * Add an exists clause to the query. |
| 21938: | * |
| 21939: | * @param \Illuminate\Database\Query\Builder $query |
| 21940: | * @param string $boolean |
| 21941: | * @param bool $not |
| 21942: | * @return \Illuminate\Database\Query\Builder |
| 21943: | * @static |
| 21944: | */ |
| 21945: | public static function addWhereExistsQuery($query, $boolean = 'and', $not = false) |
| 21946: | { |
| 21947: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21948: | return $instance->addWhereExistsQuery($query, $boolean, $not); |
| 21949: | } |
| 21950: | |
| 21951: | /** |
| 21952: | * Adds a where condition using row values. |
| 21953: | * |
| 21954: | * @param array $columns |
| 21955: | * @param string $operator |
| 21956: | * @param array $values |
| 21957: | * @param string $boolean |
| 21958: | * @return \Illuminate\Database\Query\Builder |
| 21959: | * @throws \InvalidArgumentException |
| 21960: | * @static |
| 21961: | */ |
| 21962: | public static function whereRowValues($columns, $operator, $values, $boolean = 'and') |
| 21963: | { |
| 21964: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21965: | return $instance->whereRowValues($columns, $operator, $values, $boolean); |
| 21966: | } |
| 21967: | |
| 21968: | /** |
| 21969: | * Adds an or where condition using row values. |
| 21970: | * |
| 21971: | * @param array $columns |
| 21972: | * @param string $operator |
| 21973: | * @param array $values |
| 21974: | * @return \Illuminate\Database\Query\Builder |
| 21975: | * @static |
| 21976: | */ |
| 21977: | public static function orWhereRowValues($columns, $operator, $values) |
| 21978: | { |
| 21979: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21980: | return $instance->orWhereRowValues($columns, $operator, $values); |
| 21981: | } |
| 21982: | |
| 21983: | /** |
| 21984: | * Add a "where JSON contains" clause to the query. |
| 21985: | * |
| 21986: | * @param string $column |
| 21987: | * @param mixed $value |
| 21988: | * @param string $boolean |
| 21989: | * @param bool $not |
| 21990: | * @return \Illuminate\Database\Query\Builder |
| 21991: | * @static |
| 21992: | */ |
| 21993: | public static function whereJsonContains($column, $value, $boolean = 'and', $not = false) |
| 21994: | { |
| 21995: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 21996: | return $instance->whereJsonContains($column, $value, $boolean, $not); |
| 21997: | } |
| 21998: | |
| 21999: | /** |
| 22000: | * Add an "or where JSON contains" clause to the query. |
| 22001: | * |
| 22002: | * @param string $column |
| 22003: | * @param mixed $value |
| 22004: | * @return \Illuminate\Database\Query\Builder |
| 22005: | * @static |
| 22006: | */ |
| 22007: | public static function orWhereJsonContains($column, $value) |
| 22008: | { |
| 22009: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22010: | return $instance->orWhereJsonContains($column, $value); |
| 22011: | } |
| 22012: | |
| 22013: | /** |
| 22014: | * Add a "where JSON not contains" clause to the query. |
| 22015: | * |
| 22016: | * @param string $column |
| 22017: | * @param mixed $value |
| 22018: | * @param string $boolean |
| 22019: | * @return \Illuminate\Database\Query\Builder |
| 22020: | * @static |
| 22021: | */ |
| 22022: | public static function whereJsonDoesntContain($column, $value, $boolean = 'and') |
| 22023: | { |
| 22024: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22025: | return $instance->whereJsonDoesntContain($column, $value, $boolean); |
| 22026: | } |
| 22027: | |
| 22028: | /** |
| 22029: | * Add an "or where JSON not contains" clause to the query. |
| 22030: | * |
| 22031: | * @param string $column |
| 22032: | * @param mixed $value |
| 22033: | * @return \Illuminate\Database\Query\Builder |
| 22034: | * @static |
| 22035: | */ |
| 22036: | public static function orWhereJsonDoesntContain($column, $value) |
| 22037: | { |
| 22038: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22039: | return $instance->orWhereJsonDoesntContain($column, $value); |
| 22040: | } |
| 22041: | |
| 22042: | /** |
| 22043: | * Add a clause that determines if a JSON path exists to the query. |
| 22044: | * |
| 22045: | * @param string $column |
| 22046: | * @param string $boolean |
| 22047: | * @param bool $not |
| 22048: | * @return \Illuminate\Database\Query\Builder |
| 22049: | * @static |
| 22050: | */ |
| 22051: | public static function whereJsonContainsKey($column, $boolean = 'and', $not = false) |
| 22052: | { |
| 22053: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22054: | return $instance->whereJsonContainsKey($column, $boolean, $not); |
| 22055: | } |
| 22056: | |
| 22057: | /** |
| 22058: | * Add an "or" clause that determines if a JSON path exists to the query. |
| 22059: | * |
| 22060: | * @param string $column |
| 22061: | * @return \Illuminate\Database\Query\Builder |
| 22062: | * @static |
| 22063: | */ |
| 22064: | public static function orWhereJsonContainsKey($column) |
| 22065: | { |
| 22066: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22067: | return $instance->orWhereJsonContainsKey($column); |
| 22068: | } |
| 22069: | |
| 22070: | /** |
| 22071: | * Add a clause that determines if a JSON path does not exist to the query. |
| 22072: | * |
| 22073: | * @param string $column |
| 22074: | * @param string $boolean |
| 22075: | * @return \Illuminate\Database\Query\Builder |
| 22076: | * @static |
| 22077: | */ |
| 22078: | public static function whereJsonDoesntContainKey($column, $boolean = 'and') |
| 22079: | { |
| 22080: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22081: | return $instance->whereJsonDoesntContainKey($column, $boolean); |
| 22082: | } |
| 22083: | |
| 22084: | /** |
| 22085: | * Add an "or" clause that determines if a JSON path does not exist to the query. |
| 22086: | * |
| 22087: | * @param string $column |
| 22088: | * @return \Illuminate\Database\Query\Builder |
| 22089: | * @static |
| 22090: | */ |
| 22091: | public static function orWhereJsonDoesntContainKey($column) |
| 22092: | { |
| 22093: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22094: | return $instance->orWhereJsonDoesntContainKey($column); |
| 22095: | } |
| 22096: | |
| 22097: | /** |
| 22098: | * Add a "where JSON length" clause to the query. |
| 22099: | * |
| 22100: | * @param string $column |
| 22101: | * @param mixed $operator |
| 22102: | * @param mixed $value |
| 22103: | * @param string $boolean |
| 22104: | * @return \Illuminate\Database\Query\Builder |
| 22105: | * @static |
| 22106: | */ |
| 22107: | public static function whereJsonLength($column, $operator, $value = null, $boolean = 'and') |
| 22108: | { |
| 22109: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22110: | return $instance->whereJsonLength($column, $operator, $value, $boolean); |
| 22111: | } |
| 22112: | |
| 22113: | /** |
| 22114: | * Add an "or where JSON length" clause to the query. |
| 22115: | * |
| 22116: | * @param string $column |
| 22117: | * @param mixed $operator |
| 22118: | * @param mixed $value |
| 22119: | * @return \Illuminate\Database\Query\Builder |
| 22120: | * @static |
| 22121: | */ |
| 22122: | public static function orWhereJsonLength($column, $operator, $value = null) |
| 22123: | { |
| 22124: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22125: | return $instance->orWhereJsonLength($column, $operator, $value); |
| 22126: | } |
| 22127: | |
| 22128: | /** |
| 22129: | * Handles dynamic "where" clauses to the query. |
| 22130: | * |
| 22131: | * @param string $method |
| 22132: | * @param array $parameters |
| 22133: | * @return \Illuminate\Database\Query\Builder |
| 22134: | * @static |
| 22135: | */ |
| 22136: | public static function dynamicWhere($method, $parameters) |
| 22137: | { |
| 22138: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22139: | return $instance->dynamicWhere($method, $parameters); |
| 22140: | } |
| 22141: | |
| 22142: | /** |
| 22143: | * Add a "where fulltext" clause to the query. |
| 22144: | * |
| 22145: | * @param string|string[] $columns |
| 22146: | * @param string $value |
| 22147: | * @param string $boolean |
| 22148: | * @return \Illuminate\Database\Query\Builder |
| 22149: | * @static |
| 22150: | */ |
| 22151: | public static function whereFullText($columns, $value, $options = [], $boolean = 'and') |
| 22152: | { |
| 22153: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22154: | return $instance->whereFullText($columns, $value, $options, $boolean); |
| 22155: | } |
| 22156: | |
| 22157: | /** |
| 22158: | * Add a "or where fulltext" clause to the query. |
| 22159: | * |
| 22160: | * @param string|string[] $columns |
| 22161: | * @param string $value |
| 22162: | * @return \Illuminate\Database\Query\Builder |
| 22163: | * @static |
| 22164: | */ |
| 22165: | public static function orWhereFullText($columns, $value, $options = []) |
| 22166: | { |
| 22167: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22168: | return $instance->orWhereFullText($columns, $value, $options); |
| 22169: | } |
| 22170: | |
| 22171: | /** |
| 22172: | * Add a "group by" clause to the query. |
| 22173: | * |
| 22174: | * @param array|string $groups |
| 22175: | * @return \Illuminate\Database\Query\Builder |
| 22176: | * @static |
| 22177: | */ |
| 22178: | public static function groupBy(...$groups) |
| 22179: | { |
| 22180: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22181: | return $instance->groupBy(...$groups); |
| 22182: | } |
| 22183: | |
| 22184: | /** |
| 22185: | * Add a raw groupBy clause to the query. |
| 22186: | * |
| 22187: | * @param string $sql |
| 22188: | * @param array $bindings |
| 22189: | * @return \Illuminate\Database\Query\Builder |
| 22190: | * @static |
| 22191: | */ |
| 22192: | public static function groupByRaw($sql, $bindings = []) |
| 22193: | { |
| 22194: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22195: | return $instance->groupByRaw($sql, $bindings); |
| 22196: | } |
| 22197: | |
| 22198: | /** |
| 22199: | * Add a "having" clause to the query. |
| 22200: | * |
| 22201: | * @param \Closure|string $column |
| 22202: | * @param string|int|float|null $operator |
| 22203: | * @param string|int|float|null $value |
| 22204: | * @param string $boolean |
| 22205: | * @return \Illuminate\Database\Query\Builder |
| 22206: | * @static |
| 22207: | */ |
| 22208: | public static function having($column, $operator = null, $value = null, $boolean = 'and') |
| 22209: | { |
| 22210: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22211: | return $instance->having($column, $operator, $value, $boolean); |
| 22212: | } |
| 22213: | |
| 22214: | /** |
| 22215: | * Add an "or having" clause to the query. |
| 22216: | * |
| 22217: | * @param \Closure|string $column |
| 22218: | * @param string|int|float|null $operator |
| 22219: | * @param string|int|float|null $value |
| 22220: | * @return \Illuminate\Database\Query\Builder |
| 22221: | * @static |
| 22222: | */ |
| 22223: | public static function orHaving($column, $operator = null, $value = null) |
| 22224: | { |
| 22225: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22226: | return $instance->orHaving($column, $operator, $value); |
| 22227: | } |
| 22228: | |
| 22229: | /** |
| 22230: | * Add a nested having statement to the query. |
| 22231: | * |
| 22232: | * @param \Closure $callback |
| 22233: | * @param string $boolean |
| 22234: | * @return \Illuminate\Database\Query\Builder |
| 22235: | * @static |
| 22236: | */ |
| 22237: | public static function havingNested($callback, $boolean = 'and') |
| 22238: | { |
| 22239: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22240: | return $instance->havingNested($callback, $boolean); |
| 22241: | } |
| 22242: | |
| 22243: | /** |
| 22244: | * Add another query builder as a nested having to the query builder. |
| 22245: | * |
| 22246: | * @param \Illuminate\Database\Query\Builder $query |
| 22247: | * @param string $boolean |
| 22248: | * @return \Illuminate\Database\Query\Builder |
| 22249: | * @static |
| 22250: | */ |
| 22251: | public static function addNestedHavingQuery($query, $boolean = 'and') |
| 22252: | { |
| 22253: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22254: | return $instance->addNestedHavingQuery($query, $boolean); |
| 22255: | } |
| 22256: | |
| 22257: | /** |
| 22258: | * Add a "having null" clause to the query. |
| 22259: | * |
| 22260: | * @param string|array $columns |
| 22261: | * @param string $boolean |
| 22262: | * @param bool $not |
| 22263: | * @return \Illuminate\Database\Query\Builder |
| 22264: | * @static |
| 22265: | */ |
| 22266: | public static function havingNull($columns, $boolean = 'and', $not = false) |
| 22267: | { |
| 22268: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22269: | return $instance->havingNull($columns, $boolean, $not); |
| 22270: | } |
| 22271: | |
| 22272: | /** |
| 22273: | * Add an "or having null" clause to the query. |
| 22274: | * |
| 22275: | * @param string $column |
| 22276: | * @return \Illuminate\Database\Query\Builder |
| 22277: | * @static |
| 22278: | */ |
| 22279: | public static function orHavingNull($column) |
| 22280: | { |
| 22281: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22282: | return $instance->orHavingNull($column); |
| 22283: | } |
| 22284: | |
| 22285: | /** |
| 22286: | * Add a "having not null" clause to the query. |
| 22287: | * |
| 22288: | * @param string|array $columns |
| 22289: | * @param string $boolean |
| 22290: | * @return \Illuminate\Database\Query\Builder |
| 22291: | * @static |
| 22292: | */ |
| 22293: | public static function havingNotNull($columns, $boolean = 'and') |
| 22294: | { |
| 22295: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22296: | return $instance->havingNotNull($columns, $boolean); |
| 22297: | } |
| 22298: | |
| 22299: | /** |
| 22300: | * Add an "or having not null" clause to the query. |
| 22301: | * |
| 22302: | * @param string $column |
| 22303: | * @return \Illuminate\Database\Query\Builder |
| 22304: | * @static |
| 22305: | */ |
| 22306: | public static function orHavingNotNull($column) |
| 22307: | { |
| 22308: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22309: | return $instance->orHavingNotNull($column); |
| 22310: | } |
| 22311: | |
| 22312: | /** |
| 22313: | * Add a "having between " clause to the query. |
| 22314: | * |
| 22315: | * @param string $column |
| 22316: | * @param array $values |
| 22317: | * @param string $boolean |
| 22318: | * @param bool $not |
| 22319: | * @return \Illuminate\Database\Query\Builder |
| 22320: | * @static |
| 22321: | */ |
| 22322: | public static function havingBetween($column, $values, $boolean = 'and', $not = false) |
| 22323: | { |
| 22324: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22325: | return $instance->havingBetween($column, $values, $boolean, $not); |
| 22326: | } |
| 22327: | |
| 22328: | /** |
| 22329: | * Add a raw having clause to the query. |
| 22330: | * |
| 22331: | * @param string $sql |
| 22332: | * @param array $bindings |
| 22333: | * @param string $boolean |
| 22334: | * @return \Illuminate\Database\Query\Builder |
| 22335: | * @static |
| 22336: | */ |
| 22337: | public static function havingRaw($sql, $bindings = [], $boolean = 'and') |
| 22338: | { |
| 22339: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22340: | return $instance->havingRaw($sql, $bindings, $boolean); |
| 22341: | } |
| 22342: | |
| 22343: | /** |
| 22344: | * Add a raw or having clause to the query. |
| 22345: | * |
| 22346: | * @param string $sql |
| 22347: | * @param array $bindings |
| 22348: | * @return \Illuminate\Database\Query\Builder |
| 22349: | * @static |
| 22350: | */ |
| 22351: | public static function orHavingRaw($sql, $bindings = []) |
| 22352: | { |
| 22353: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22354: | return $instance->orHavingRaw($sql, $bindings); |
| 22355: | } |
| 22356: | |
| 22357: | /** |
| 22358: | * Add an "order by" clause to the query. |
| 22359: | * |
| 22360: | * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Query\Expression|string $column |
| 22361: | * @param string $direction |
| 22362: | * @return \Illuminate\Database\Query\Builder |
| 22363: | * @throws \InvalidArgumentException |
| 22364: | * @static |
| 22365: | */ |
| 22366: | public static function orderBy($column, $direction = 'asc') |
| 22367: | { |
| 22368: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22369: | return $instance->orderBy($column, $direction); |
| 22370: | } |
| 22371: | |
| 22372: | /** |
| 22373: | * Add a descending "order by" clause to the query. |
| 22374: | * |
| 22375: | * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Query\Expression|string $column |
| 22376: | * @return \Illuminate\Database\Query\Builder |
| 22377: | * @static |
| 22378: | */ |
| 22379: | public static function orderByDesc($column) |
| 22380: | { |
| 22381: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22382: | return $instance->orderByDesc($column); |
| 22383: | } |
| 22384: | |
| 22385: | /** |
| 22386: | * Put the query's results in random order. |
| 22387: | * |
| 22388: | * @param string $seed |
| 22389: | * @return \Illuminate\Database\Query\Builder |
| 22390: | * @static |
| 22391: | */ |
| 22392: | public static function inRandomOrder($seed = '') |
| 22393: | { |
| 22394: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22395: | return $instance->inRandomOrder($seed); |
| 22396: | } |
| 22397: | |
| 22398: | /** |
| 22399: | * Add a raw "order by" clause to the query. |
| 22400: | * |
| 22401: | * @param string $sql |
| 22402: | * @param array $bindings |
| 22403: | * @return \Illuminate\Database\Query\Builder |
| 22404: | * @static |
| 22405: | */ |
| 22406: | public static function orderByRaw($sql, $bindings = []) |
| 22407: | { |
| 22408: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22409: | return $instance->orderByRaw($sql, $bindings); |
| 22410: | } |
| 22411: | |
| 22412: | /** |
| 22413: | * Alias to set the "offset" value of the query. |
| 22414: | * |
| 22415: | * @param int $value |
| 22416: | * @return \Illuminate\Database\Query\Builder |
| 22417: | * @static |
| 22418: | */ |
| 22419: | public static function skip($value) |
| 22420: | { |
| 22421: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22422: | return $instance->skip($value); |
| 22423: | } |
| 22424: | |
| 22425: | /** |
| 22426: | * Set the "offset" value of the query. |
| 22427: | * |
| 22428: | * @param int $value |
| 22429: | * @return \Illuminate\Database\Query\Builder |
| 22430: | * @static |
| 22431: | */ |
| 22432: | public static function offset($value) |
| 22433: | { |
| 22434: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22435: | return $instance->offset($value); |
| 22436: | } |
| 22437: | |
| 22438: | /** |
| 22439: | * Alias to set the "limit" value of the query. |
| 22440: | * |
| 22441: | * @param int $value |
| 22442: | * @return \Illuminate\Database\Query\Builder |
| 22443: | * @static |
| 22444: | */ |
| 22445: | public static function take($value) |
| 22446: | { |
| 22447: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22448: | return $instance->take($value); |
| 22449: | } |
| 22450: | |
| 22451: | /** |
| 22452: | * Set the "limit" value of the query. |
| 22453: | * |
| 22454: | * @param int $value |
| 22455: | * @return \Illuminate\Database\Query\Builder |
| 22456: | * @static |
| 22457: | */ |
| 22458: | public static function limit($value) |
| 22459: | { |
| 22460: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22461: | return $instance->limit($value); |
| 22462: | } |
| 22463: | |
| 22464: | /** |
| 22465: | * Set the limit and offset for a given page. |
| 22466: | * |
| 22467: | * @param int $page |
| 22468: | * @param int $perPage |
| 22469: | * @return \Illuminate\Database\Query\Builder |
| 22470: | * @static |
| 22471: | */ |
| 22472: | public static function forPage($page, $perPage = 15) |
| 22473: | { |
| 22474: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22475: | return $instance->forPage($page, $perPage); |
| 22476: | } |
| 22477: | |
| 22478: | /** |
| 22479: | * Constrain the query to the previous "page" of results before a given ID. |
| 22480: | * |
| 22481: | * @param int $perPage |
| 22482: | * @param int|null $lastId |
| 22483: | * @param string $column |
| 22484: | * @return \Illuminate\Database\Query\Builder |
| 22485: | * @static |
| 22486: | */ |
| 22487: | public static function forPageBeforeId($perPage = 15, $lastId = 0, $column = 'id') |
| 22488: | { |
| 22489: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22490: | return $instance->forPageBeforeId($perPage, $lastId, $column); |
| 22491: | } |
| 22492: | |
| 22493: | /** |
| 22494: | * Constrain the query to the next "page" of results after a given ID. |
| 22495: | * |
| 22496: | * @param int $perPage |
| 22497: | * @param int|null $lastId |
| 22498: | * @param string $column |
| 22499: | * @return \Illuminate\Database\Query\Builder |
| 22500: | * @static |
| 22501: | */ |
| 22502: | public static function forPageAfterId($perPage = 15, $lastId = 0, $column = 'id') |
| 22503: | { |
| 22504: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22505: | return $instance->forPageAfterId($perPage, $lastId, $column); |
| 22506: | } |
| 22507: | |
| 22508: | /** |
| 22509: | * Remove all existing orders and optionally add a new order. |
| 22510: | * |
| 22511: | * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Query\Expression|string|null $column |
| 22512: | * @param string $direction |
| 22513: | * @return \Illuminate\Database\Query\Builder |
| 22514: | * @static |
| 22515: | */ |
| 22516: | public static function reorder($column = null, $direction = 'asc') |
| 22517: | { |
| 22518: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22519: | return $instance->reorder($column, $direction); |
| 22520: | } |
| 22521: | |
| 22522: | /** |
| 22523: | * Add a union statement to the query. |
| 22524: | * |
| 22525: | * @param \Illuminate\Database\Query\Builder|\Closure $query |
| 22526: | * @param bool $all |
| 22527: | * @return \Illuminate\Database\Query\Builder |
| 22528: | * @static |
| 22529: | */ |
| 22530: | public static function union($query, $all = false) |
| 22531: | { |
| 22532: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22533: | return $instance->union($query, $all); |
| 22534: | } |
| 22535: | |
| 22536: | /** |
| 22537: | * Add a union all statement to the query. |
| 22538: | * |
| 22539: | * @param \Illuminate\Database\Query\Builder|\Closure $query |
| 22540: | * @return \Illuminate\Database\Query\Builder |
| 22541: | * @static |
| 22542: | */ |
| 22543: | public static function unionAll($query) |
| 22544: | { |
| 22545: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22546: | return $instance->unionAll($query); |
| 22547: | } |
| 22548: | |
| 22549: | /** |
| 22550: | * Lock the selected rows in the table. |
| 22551: | * |
| 22552: | * @param string|bool $value |
| 22553: | * @return \Illuminate\Database\Query\Builder |
| 22554: | * @static |
| 22555: | */ |
| 22556: | public static function lock($value = true) |
| 22557: | { |
| 22558: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22559: | return $instance->lock($value); |
| 22560: | } |
| 22561: | |
| 22562: | /** |
| 22563: | * Lock the selected rows in the table for updating. |
| 22564: | * |
| 22565: | * @return \Illuminate\Database\Query\Builder |
| 22566: | * @static |
| 22567: | */ |
| 22568: | public static function lockForUpdate() |
| 22569: | { |
| 22570: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22571: | return $instance->lockForUpdate(); |
| 22572: | } |
| 22573: | |
| 22574: | /** |
| 22575: | * Share lock the selected rows in the table. |
| 22576: | * |
| 22577: | * @return \Illuminate\Database\Query\Builder |
| 22578: | * @static |
| 22579: | */ |
| 22580: | public static function sharedLock() |
| 22581: | { |
| 22582: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22583: | return $instance->sharedLock(); |
| 22584: | } |
| 22585: | |
| 22586: | /** |
| 22587: | * Register a closure to be invoked before the query is executed. |
| 22588: | * |
| 22589: | * @param callable $callback |
| 22590: | * @return \Illuminate\Database\Query\Builder |
| 22591: | * @static |
| 22592: | */ |
| 22593: | public static function beforeQuery($callback) |
| 22594: | { |
| 22595: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22596: | return $instance->beforeQuery($callback); |
| 22597: | } |
| 22598: | |
| 22599: | /** |
| 22600: | * Invoke the "before query" modification callbacks. |
| 22601: | * |
| 22602: | * @return void |
| 22603: | * @static |
| 22604: | */ |
| 22605: | public static function applyBeforeQueryCallbacks() |
| 22606: | { |
| 22607: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22608: | $instance->applyBeforeQueryCallbacks(); |
| 22609: | } |
| 22610: | |
| 22611: | /** |
| 22612: | * Get the SQL representation of the query. |
| 22613: | * |
| 22614: | * @return string |
| 22615: | * @static |
| 22616: | */ |
| 22617: | public static function toSql() |
| 22618: | { |
| 22619: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22620: | return $instance->toSql(); |
| 22621: | } |
| 22622: | |
| 22623: | /** |
| 22624: | * Get the count of the total records for the paginator. |
| 22625: | * |
| 22626: | * @param array $columns |
| 22627: | * @return int |
| 22628: | * @static |
| 22629: | */ |
| 22630: | public static function getCountForPagination($columns = []) |
| 22631: | { |
| 22632: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22633: | return $instance->getCountForPagination($columns); |
| 22634: | } |
| 22635: | |
| 22636: | /** |
| 22637: | * Concatenate values of a given column as a string. |
| 22638: | * |
| 22639: | * @param string $column |
| 22640: | * @param string $glue |
| 22641: | * @return string |
| 22642: | * @static |
| 22643: | */ |
| 22644: | public static function implode($column, $glue = '') |
| 22645: | { |
| 22646: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22647: | return $instance->implode($column, $glue); |
| 22648: | } |
| 22649: | |
| 22650: | /** |
| 22651: | * Determine if any rows exist for the current query. |
| 22652: | * |
| 22653: | * @return bool |
| 22654: | * @static |
| 22655: | */ |
| 22656: | public static function exists() |
| 22657: | { |
| 22658: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22659: | return $instance->exists(); |
| 22660: | } |
| 22661: | |
| 22662: | /** |
| 22663: | * Determine if no rows exist for the current query. |
| 22664: | * |
| 22665: | * @return bool |
| 22666: | * @static |
| 22667: | */ |
| 22668: | public static function doesntExist() |
| 22669: | { |
| 22670: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22671: | return $instance->doesntExist(); |
| 22672: | } |
| 22673: | |
| 22674: | /** |
| 22675: | * Execute the given callback if no rows exist for the current query. |
| 22676: | * |
| 22677: | * @param \Closure $callback |
| 22678: | * @return mixed |
| 22679: | * @static |
| 22680: | */ |
| 22681: | public static function existsOr($callback) |
| 22682: | { |
| 22683: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22684: | return $instance->existsOr($callback); |
| 22685: | } |
| 22686: | |
| 22687: | /** |
| 22688: | * Execute the given callback if rows exist for the current query. |
| 22689: | * |
| 22690: | * @param \Closure $callback |
| 22691: | * @return mixed |
| 22692: | * @static |
| 22693: | */ |
| 22694: | public static function doesntExistOr($callback) |
| 22695: | { |
| 22696: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22697: | return $instance->doesntExistOr($callback); |
| 22698: | } |
| 22699: | |
| 22700: | /** |
| 22701: | * Retrieve the "count" result of the query. |
| 22702: | * |
| 22703: | * @param string $columns |
| 22704: | * @return int |
| 22705: | * @static |
| 22706: | */ |
| 22707: | public static function count($columns = '*') |
| 22708: | { |
| 22709: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22710: | return $instance->count($columns); |
| 22711: | } |
| 22712: | |
| 22713: | /** |
| 22714: | * Retrieve the minimum value of a given column. |
| 22715: | * |
| 22716: | * @param string $column |
| 22717: | * @return mixed |
| 22718: | * @static |
| 22719: | */ |
| 22720: | public static function min($column) |
| 22721: | { |
| 22722: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22723: | return $instance->min($column); |
| 22724: | } |
| 22725: | |
| 22726: | /** |
| 22727: | * Retrieve the maximum value of a given column. |
| 22728: | * |
| 22729: | * @param string $column |
| 22730: | * @return mixed |
| 22731: | * @static |
| 22732: | */ |
| 22733: | public static function max($column) |
| 22734: | { |
| 22735: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22736: | return $instance->max($column); |
| 22737: | } |
| 22738: | |
| 22739: | /** |
| 22740: | * Retrieve the sum of the values of a given column. |
| 22741: | * |
| 22742: | * @param string $column |
| 22743: | * @return mixed |
| 22744: | * @static |
| 22745: | */ |
| 22746: | public static function sum($column) |
| 22747: | { |
| 22748: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22749: | return $instance->sum($column); |
| 22750: | } |
| 22751: | |
| 22752: | /** |
| 22753: | * Retrieve the average of the values of a given column. |
| 22754: | * |
| 22755: | * @param string $column |
| 22756: | * @return mixed |
| 22757: | * @static |
| 22758: | */ |
| 22759: | public static function avg($column) |
| 22760: | { |
| 22761: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22762: | return $instance->avg($column); |
| 22763: | } |
| 22764: | |
| 22765: | /** |
| 22766: | * Alias for the "avg" method. |
| 22767: | * |
| 22768: | * @param string $column |
| 22769: | * @return mixed |
| 22770: | * @static |
| 22771: | */ |
| 22772: | public static function average($column) |
| 22773: | { |
| 22774: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22775: | return $instance->average($column); |
| 22776: | } |
| 22777: | |
| 22778: | /** |
| 22779: | * Execute an aggregate function on the database. |
| 22780: | * |
| 22781: | * @param string $function |
| 22782: | * @param array $columns |
| 22783: | * @return mixed |
| 22784: | * @static |
| 22785: | */ |
| 22786: | public static function aggregate($function, $columns = []) |
| 22787: | { |
| 22788: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22789: | return $instance->aggregate($function, $columns); |
| 22790: | } |
| 22791: | |
| 22792: | /** |
| 22793: | * Execute a numeric aggregate function on the database. |
| 22794: | * |
| 22795: | * @param string $function |
| 22796: | * @param array $columns |
| 22797: | * @return float|int |
| 22798: | * @static |
| 22799: | */ |
| 22800: | public static function numericAggregate($function, $columns = []) |
| 22801: | { |
| 22802: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22803: | return $instance->numericAggregate($function, $columns); |
| 22804: | } |
| 22805: | |
| 22806: | /** |
| 22807: | * Insert new records into the database. |
| 22808: | * |
| 22809: | * @param array $values |
| 22810: | * @return bool |
| 22811: | * @static |
| 22812: | */ |
| 22813: | public static function insert($values) |
| 22814: | { |
| 22815: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22816: | return $instance->insert($values); |
| 22817: | } |
| 22818: | |
| 22819: | /** |
| 22820: | * Insert new records into the database while ignoring errors. |
| 22821: | * |
| 22822: | * @param array $values |
| 22823: | * @return int |
| 22824: | * @static |
| 22825: | */ |
| 22826: | public static function insertOrIgnore($values) |
| 22827: | { |
| 22828: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22829: | return $instance->insertOrIgnore($values); |
| 22830: | } |
| 22831: | |
| 22832: | /** |
| 22833: | * Insert a new record and get the value of the primary key. |
| 22834: | * |
| 22835: | * @param array $values |
| 22836: | * @param string|null $sequence |
| 22837: | * @return int |
| 22838: | * @static |
| 22839: | */ |
| 22840: | public static function insertGetId($values, $sequence = null) |
| 22841: | { |
| 22842: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22843: | return $instance->insertGetId($values, $sequence); |
| 22844: | } |
| 22845: | |
| 22846: | /** |
| 22847: | * Insert new records into the table using a subquery. |
| 22848: | * |
| 22849: | * @param array $columns |
| 22850: | * @param \Closure|\Illuminate\Database\Query\Builder|string $query |
| 22851: | * @return int |
| 22852: | * @static |
| 22853: | */ |
| 22854: | public static function insertUsing($columns, $query) |
| 22855: | { |
| 22856: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22857: | return $instance->insertUsing($columns, $query); |
| 22858: | } |
| 22859: | |
| 22860: | /** |
| 22861: | * Update records in a PostgreSQL database using the update from syntax. |
| 22862: | * |
| 22863: | * @param array $values |
| 22864: | * @return int |
| 22865: | * @static |
| 22866: | */ |
| 22867: | public static function updateFrom($values) |
| 22868: | { |
| 22869: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22870: | return $instance->updateFrom($values); |
| 22871: | } |
| 22872: | |
| 22873: | /** |
| 22874: | * Insert or update a record matching the attributes, and fill it with values. |
| 22875: | * |
| 22876: | * @param array $attributes |
| 22877: | * @param array $values |
| 22878: | * @return bool |
| 22879: | * @static |
| 22880: | */ |
| 22881: | public static function updateOrInsert($attributes, $values = []) |
| 22882: | { |
| 22883: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22884: | return $instance->updateOrInsert($attributes, $values); |
| 22885: | } |
| 22886: | |
| 22887: | /** |
| 22888: | * Run a truncate statement on the table. |
| 22889: | * |
| 22890: | * @return void |
| 22891: | * @static |
| 22892: | */ |
| 22893: | public static function truncate() |
| 22894: | { |
| 22895: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22896: | $instance->truncate(); |
| 22897: | } |
| 22898: | |
| 22899: | /** |
| 22900: | * Create a raw database expression. |
| 22901: | * |
| 22902: | * @param mixed $value |
| 22903: | * @return \Illuminate\Database\Query\Expression |
| 22904: | * @static |
| 22905: | */ |
| 22906: | public static function raw($value) |
| 22907: | { |
| 22908: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22909: | return $instance->raw($value); |
| 22910: | } |
| 22911: | |
| 22912: | /** |
| 22913: | * Get the current query value bindings in a flattened array. |
| 22914: | * |
| 22915: | * @return array |
| 22916: | * @static |
| 22917: | */ |
| 22918: | public static function getBindings() |
| 22919: | { |
| 22920: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22921: | return $instance->getBindings(); |
| 22922: | } |
| 22923: | |
| 22924: | /** |
| 22925: | * Get the raw array of bindings. |
| 22926: | * |
| 22927: | * @return array |
| 22928: | * @static |
| 22929: | */ |
| 22930: | public static function getRawBindings() |
| 22931: | { |
| 22932: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22933: | return $instance->getRawBindings(); |
| 22934: | } |
| 22935: | |
| 22936: | /** |
| 22937: | * Set the bindings on the query builder. |
| 22938: | * |
| 22939: | * @param array $bindings |
| 22940: | * @param string $type |
| 22941: | * @return \Illuminate\Database\Query\Builder |
| 22942: | * @throws \InvalidArgumentException |
| 22943: | * @static |
| 22944: | */ |
| 22945: | public static function setBindings($bindings, $type = 'where') |
| 22946: | { |
| 22947: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22948: | return $instance->setBindings($bindings, $type); |
| 22949: | } |
| 22950: | |
| 22951: | /** |
| 22952: | * Add a binding to the query. |
| 22953: | * |
| 22954: | * @param mixed $value |
| 22955: | * @param string $type |
| 22956: | * @return \Illuminate\Database\Query\Builder |
| 22957: | * @throws \InvalidArgumentException |
| 22958: | * @static |
| 22959: | */ |
| 22960: | public static function addBinding($value, $type = 'where') |
| 22961: | { |
| 22962: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22963: | return $instance->addBinding($value, $type); |
| 22964: | } |
| 22965: | |
| 22966: | /** |
| 22967: | * Cast the given binding value. |
| 22968: | * |
| 22969: | * @param mixed $value |
| 22970: | * @return mixed |
| 22971: | * @static |
| 22972: | */ |
| 22973: | public static function castBinding($value) |
| 22974: | { |
| 22975: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22976: | return $instance->castBinding($value); |
| 22977: | } |
| 22978: | |
| 22979: | /** |
| 22980: | * Merge an array of bindings into our bindings. |
| 22981: | * |
| 22982: | * @param \Illuminate\Database\Query\Builder $query |
| 22983: | * @return \Illuminate\Database\Query\Builder |
| 22984: | * @static |
| 22985: | */ |
| 22986: | public static function mergeBindings($query) |
| 22987: | { |
| 22988: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 22989: | return $instance->mergeBindings($query); |
| 22990: | } |
| 22991: | |
| 22992: | /** |
| 22993: | * Remove all of the expressions from a list of bindings. |
| 22994: | * |
| 22995: | * @param array $bindings |
| 22996: | * @return array |
| 22997: | * @static |
| 22998: | */ |
| 22999: | public static function cleanBindings($bindings) |
| 23000: | { |
| 23001: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 23002: | return $instance->cleanBindings($bindings); |
| 23003: | } |
| 23004: | |
| 23005: | /** |
| 23006: | * Get the database query processor instance. |
| 23007: | * |
| 23008: | * @return \Illuminate\Database\Query\Processors\Processor |
| 23009: | * @static |
| 23010: | */ |
| 23011: | public static function getProcessor() |
| 23012: | { |
| 23013: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 23014: | return $instance->getProcessor(); |
| 23015: | } |
| 23016: | |
| 23017: | /** |
| 23018: | * Get the query grammar instance. |
| 23019: | * |
| 23020: | * @return \Illuminate\Database\Query\Grammars\Grammar |
| 23021: | * @static |
| 23022: | */ |
| 23023: | public static function getGrammar() |
| 23024: | { |
| 23025: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 23026: | return $instance->getGrammar(); |
| 23027: | } |
| 23028: | |
| 23029: | /** |
| 23030: | * Use the "write" PDO connection when executing the query. |
| 23031: | * |
| 23032: | * @return \Illuminate\Database\Query\Builder |
| 23033: | * @static |
| 23034: | */ |
| 23035: | public static function useWritePdo() |
| 23036: | { |
| 23037: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 23038: | return $instance->useWritePdo(); |
| 23039: | } |
| 23040: | |
| 23041: | /** |
| 23042: | * Clone the query without the given properties. |
| 23043: | * |
| 23044: | * @param array $properties |
| 23045: | * @return static |
| 23046: | * @static |
| 23047: | */ |
| 23048: | public static function cloneWithout($properties) |
| 23049: | { |
| 23050: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 23051: | return $instance->cloneWithout($properties); |
| 23052: | } |
| 23053: | |
| 23054: | /** |
| 23055: | * Clone the query without the given bindings. |
| 23056: | * |
| 23057: | * @param array $except |
| 23058: | * @return static |
| 23059: | * @static |
| 23060: | */ |
| 23061: | public static function cloneWithoutBindings($except) |
| 23062: | { |
| 23063: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 23064: | return $instance->cloneWithoutBindings($except); |
| 23065: | } |
| 23066: | |
| 23067: | /** |
| 23068: | * Dump the current SQL and bindings. |
| 23069: | * |
| 23070: | * @return \Illuminate\Database\Query\Builder |
| 23071: | * @static |
| 23072: | */ |
| 23073: | public static function dump() |
| 23074: | { |
| 23075: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 23076: | return $instance->dump(); |
| 23077: | } |
| 23078: | |
| 23079: | /** |
| 23080: | * Die and dump the current SQL and bindings. |
| 23081: | * |
| 23082: | * @return \Illuminate\Database\Query\never |
| 23083: | * @static |
| 23084: | */ |
| 23085: | public static function dd() |
| 23086: | { |
| 23087: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 23088: | return $instance->dd(); |
| 23089: | } |
| 23090: | |
| 23091: | /** |
| 23092: | * Explains the query. |
| 23093: | * |
| 23094: | * @return \Illuminate\Support\Collection |
| 23095: | * @static |
| 23096: | */ |
| 23097: | public static function explain() |
| 23098: | { |
| 23099: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 23100: | return $instance->explain(); |
| 23101: | } |
| 23102: | |
| 23103: | /** |
| 23104: | * Register a custom macro. |
| 23105: | * |
| 23106: | * @param string $name |
| 23107: | * @param object|callable $macro |
| 23108: | * @return void |
| 23109: | * @static |
| 23110: | */ |
| 23111: | public static function macro($name, $macro) |
| 23112: | { |
| 23113: | \Illuminate\Database\Query\Builder::macro($name, $macro); |
| 23114: | } |
| 23115: | |
| 23116: | /** |
| 23117: | * Mix another object into the class. |
| 23118: | * |
| 23119: | * @param object $mixin |
| 23120: | * @param bool $replace |
| 23121: | * @return void |
| 23122: | * @throws \ReflectionException |
| 23123: | * @static |
| 23124: | */ |
| 23125: | public static function mixin($mixin, $replace = true) |
| 23126: | { |
| 23127: | \Illuminate\Database\Query\Builder::mixin($mixin, $replace); |
| 23128: | } |
| 23129: | |
| 23130: | /** |
| 23131: | * Flush the existing macros. |
| 23132: | * |
| 23133: | * @return void |
| 23134: | * @static |
| 23135: | */ |
| 23136: | public static function flushMacros() |
| 23137: | { |
| 23138: | \Illuminate\Database\Query\Builder::flushMacros(); |
| 23139: | } |
| 23140: | |
| 23141: | /** |
| 23142: | * Dynamically handle calls to the class. |
| 23143: | * |
| 23144: | * @param string $method |
| 23145: | * @param array $parameters |
| 23146: | * @return mixed |
| 23147: | * @throws \BadMethodCallException |
| 23148: | * @static |
| 23149: | */ |
| 23150: | public static function macroCall($method, $parameters) |
| 23151: | { |
| 23152: | /** @var \Illuminate\Database\Query\Builder $instance */ |
| 23153: | return $instance->macroCall($method, $parameters); |
| 23154: | } |
| 23155: | |
| 23156: | /** |
| 23157: | * |
| 23158: | * |
| 23159: | * @see \Spatie\LaravelRay\RayServiceProvider::registerMacros() |
| 23160: | * @static |
| 23161: | */ |
| 23162: | public static function ray() |
| 23163: | { |
| 23164: | return \Illuminate\Database\Query\Builder::ray(); |
| 23165: | } |
| 23166: | } |
| 23167: | class Event extends \Illuminate\Support\Facades\Event {} |
| 23168: | class File extends \Illuminate\Support\Facades\File {} |
| 23169: | class Gate extends \Illuminate\Support\Facades\Gate {} |
| 23170: | class Hash extends \Illuminate\Support\Facades\Hash {} |
| 23171: | class Http extends \Illuminate\Support\Facades\Http {} |
| 23172: | class Lang extends \Illuminate\Support\Facades\Lang {} |
| 23173: | class Log extends \Illuminate\Support\Facades\Log {} |
| 23174: | class Mail extends \Illuminate\Support\Facades\Mail {} |
| 23175: | class Notification extends \Illuminate\Support\Facades\Notification {} |
| 23176: | class Password extends \Illuminate\Support\Facades\Password {} |
| 23177: | class Queue extends \Illuminate\Support\Facades\Queue {} |
| 23178: | class RateLimiter extends \Illuminate\Support\Facades\RateLimiter {} |
| 23179: | class Redirect extends \Illuminate\Support\Facades\Redirect {} |
| 23180: | class Request extends \Illuminate\Support\Facades\Request {} |
| 23181: | class Response extends \Illuminate\Support\Facades\Response {} |
| 23182: | class Route extends \Illuminate\Support\Facades\Route {} |
| 23183: | class Schema extends \Illuminate\Support\Facades\Schema {} |
| 23184: | class Session extends \Illuminate\Support\Facades\Session {} |
| 23185: | class Storage extends \Illuminate\Support\Facades\Storage {} |
| 23186: | class Str extends \Illuminate\Support\Str {} |
| 23187: | class URL extends \Illuminate\Support\Facades\URL {} |
| 23188: | class Validator extends \Illuminate\Support\Facades\Validator {} |
| 23189: | class View extends \Illuminate\Support\Facades\View {} |
| 23190: | class Clockwork extends \Clockwork\Support\Laravel\Facade {} |
| 23191: | class Agent extends \Jenssegers\Agent\Facades\Agent {} |
| 23192: | class Livewire extends \Livewire\Livewire {} |
| 23193: | class Action extends \Lorisleiva\Actions\Facades\Actions {} |
| 23194: | class Lody extends \Lorisleiva\Lody\Lody {} |
| 23195: | class Stopwatch extends \BeyondCode\ServerTiming\Facades\ServerTiming {} |
| 23196: | class Flare extends \Spatie\LaravelIgnition\Facades\Flare {} |
| 23197: | |
| 23198: | } |
| 23199: | |
| 23200: | |
| 23201: | |
| 23202: | |
| 23203: |